Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

[WIP] Mavra ORPG


Socuine
 Share

Recommended Posts

@Joyce:

> Are you sure you want to set 1280 × 720 as a minimum resolution? 2D games are often played by people with awful computers or old hardware, so your safest bet would be to start at 800 x 600 for the sake of compatibility and to draw the largest crowd you possibly can.

I haven't decided yet if the minimum will be 1024x768 or 720p, however, either way, the people with awful computers won't be able to play, because XNA GS4.0 isn't supported on their BS.

In fact, if anyone here doesn't have Windows XP, Vista, 7, or 8, with DirectX 9.0c or higher, you should probably quit dreaming about playing this game. Because it is only supported on those plaatforms.

Thanks,
Aero/EBrown
Link to comment
Share on other sites

  • Replies 63
  • Created
  • Last Reply

Top Posters In This Topic

I don't think that's the right standpoint to take when designing 2D games, because they tend to attract more people with older hardware and software, seeing as they are generally much less resource intensive(Although I should've known this wasn't the case here, XNA and .NET are god awful for performance on older hardware). But, it's your game. :] I was just sharing my thoughts on the matter.
Link to comment
Share on other sites

@Joyce:

> I don't think that's the right standpoint to take when designing 2D games, because they tend to attract more people with older hardware and software, seeing as they are generally much less resource intensive. But, it's your game. :] I was just sharing my thoughts on the matter.

I'm just leaving [this article](http://www.pyrogon.com/about/diary/2_26_2002.php) here. It pretty much lists the reasons why my code is written to support Microsoft Windows 95 and later (although the actual binaries are usually for Microsoft Windows 2000 and later), Linux and Apple Mac OS X, and why I would even go out of the way to support other operating systems such as FreeBSD and Sun/Oracle Solaris, as long as there is a desire for support for those operating systems.

Yours faithfully
  S.J.R. van Schaik.
Link to comment
Share on other sites

@Joyce:

> I don't think that's the right standpoint to take when designing 2D games, because they tend to attract more people with older hardware and software, seeing as they are generally much less resource intensive(Although I should've known this wasn't the case here, XNA and .NET are god awful for performance on older hardware). But, it's your game. :] I was just sharing my thoughts on the matter.

You want it done that way, then you programme it. I don't know any of the cross-system languages well (Like C, or C++, or any of them) so I am using what is comfortable to me. I know that I have enough knowledge to use C# to create what we have envisioned here, so I plan to use it.

Thanks,
Aero/EBrown
Link to comment
Share on other sites

@Dawntide:

> Not sure why, but i am 100% sure that i saw all these tiles somewhere else before.

I have no idea what causes that. For one, I'm against plagiarism and I'm pretty sure Nook shares that with me. If you're 100% sure of your assumption, please prove this to me.

Best regards,
Socuine
Link to comment
Share on other sites

Parts of it reminded me of say, Inquisitor's work. Or similar styles, but I don't think I've seen them just like this though.
@Aeroplane:

> You want it done that way, then you programme it. I don't know any of the cross-system languages well (Like C, or C++, or any of them) so I am using what is comfortable to me. I know that I have enough knowledge to use C# to create what we have envisioned here, so I plan to use it.
>
> Thanks,
> Aero/EBrown

I'm sorry if it sounded demanded, wasn't the intention. I just wanted to share my thoughts on your choice of resolutions.
Link to comment
Share on other sites

@Socuine:

> I have no idea what causes that. For one, I'm against plagiarism and I'm pretty sure Nook shares that with me. If you're 100% sure of your assumption, please prove this to me.
>
> Best regards,
> Socuine

He's probably referring to Nook's show off post with the tiles :p
Link to comment
Share on other sites

A couple things on the engine:

First off, I am designing it entirely from the ground-up. I'm not using any external libraries, I am building my own.
Second, I am going to use this to learn more appropriate OOP techniques, and as such, the Mavra code may nto be the most optimized code on earth. (I'm sure someone will hate about this, but you have to give me credit for my honesty.)
Third, I am designing the attributes system in a very specific way. In fact, sprite-sheets will reflect this. A sneak peek of DirectionBlocks:

```
    [Flags]
    public enum DirectionBlock
    {
        None = 0x00,
        EntityUp = 0x01,
        EntityDown = 0x02,
        EntityLeft = 0x04,
        EntityRight = 0x08,
        ProjectileUp = 0x10,
        ProjectileDown = 0x20,
        ProjectileLeft = 0x40,
        ProjectileRight = 0x80,
    }
```
Essentially, this will mean you can set one of 256 combinations of direction blocks. Essentially, the player direction is defined something like:

```
    [Flags]
    public enum PlayerDirections
    {
        None = 0x00,
        Up = 0x01,
        Down = 0x02,
        Left = 0x04,
        Right = 0x08,
    }
```
This means that with a single call all direction blocks can be checked. This also means I will not be using Block tiles, or Map-Transition-Block tiles. Instead, a DirectionBlock can accomplish the same thing as they work for when the player is going out of the map.

I'll post more stuff in a week or two when I get settled in college. For now, I gotta go guys, but I'll be back as soon as possible. (Probably tomorrow or Sunday. Well, I have to be back Sunday. >.>)

Thanks,
Aero/EBrown
Link to comment
Share on other sites

The way I am planning out the programming, I can check a DirectionBlock with a single-statement if:

```
if ((map.GetDirectionBlock() & player.GetPlayerDirection()) == 0)
{
    /* They CAN move this direction. */
}
```
Essentially, that will take care of every possible combination, as if the AND returns 0, then the players direction cannot possibly be blocked. (Basic Boolean Math)

Say this is the direction block (bits in order from 128, 64, 32, 16, 8, 4, 2, 1):
```
00001010 (10 = Blocking Entity Right and Down)
```
And then this would be the PlayerDirection (same order):
```
00000110 (6  = Player going Down and Left)
```
When the function AND's them (as defined by the &) it will do the following:
```
  00001010 (10 = Blocking Entity Right and Down)
x 00000110 (6  = Player going Down and Left)
__________
  00000010 (2  = The Down was matched)
```
Which, when converted to an integer, is NOT equal to 0.

(For the record, I know that you know all of this Jeff, but some of the other people here might not. This is mostly for them.)

Essentially this would work in a scenario where all directions but Up are blocked, and the player was going Up:
```
00001110 (14 = All Entity Directions except Up are Blocked)
```
And of course for the player to go up:
```
00000001 (1  = The Player is going Up.)
```
Our and works as follows:
```
  00001110 (14 = All Entity Directions except Up are Blocked)
x 00000001 (1  = The Player is going Up.)
__________
  00000000 (0  = The player can move.)
```
As you can see, it's very simple to define and use.

In fact, to set multiple directions, you merely use:
```
player.PlayerDirection = PlayerDirection.Up | PlayerDirection.Left;
```
Where the | is an OR statement, saying the following:
```
  00000001 (1 = Up)
+ 00000100 (4 = Left)
__________
  00000101 (5 = UpLeft)
```
So the management of these items becomes extremely simple.

Thanks,
Aero/EBrown
Link to comment
Share on other sites

@General:

> Awesome game concept, i also love the logic behind your directional blocking ;)

There's still more, actually. I never discussed Projectiles, which as you can see in my DirectionBlock Enum, they exist.

Essentially, they will use the EXACT SAME enum as the player direction. (Which reminds me, rename PlayerDirection to Direction) So how am I going to do a simple comparison to the Direction Block? Well there's a cheat for this, that Jeff showed me.

Essentially, I am going to bitshift (<<) the Projectile Direction when I check it. Such that the if would look more like:
```
if ((map.GetDirectionBlock() & (projectile.GetProjectileDirection() << 4)) == 0)
{
    /* The projectile CAN move this direction. */
}
```
The "<< 4" means to take the binary value of the Direction, and move EVERY bit left four places. Turning:
```
00001011
```
Into:
```
10110000
```
Which essentially solidifies that it will be checked to the right direction block.

Thanks,
Aero/EBrown
Link to comment
Share on other sites

Oh yeah, no doubt Aero is doing a great job.

In the spirit of progress, here's a little teaser of sprite work. Each direction will have four frames.

![](http://i48.tinypic.com/34qk8zc.gif)

And here's a "preview" of a _possible_ look. The actual name mechanic hasn't been decided yet. It will change.

![](http://i50.tinypic.com/2nirudt.png)

All media is a work in progress, of course.
Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share


×
×
  • Create New...