Messages

Adore...are you a Smashing Pumpkins fan?

Adore is a play on words. Firstly it uses Love for its rendering and it stands for Adventure Rendering Engine.
(But i am also a Pumpkins fan and that is my favourite pumpkins album )

Maybe a dumb question but could an AGS project be "transfered" to Adore without too much hassle?

Short answer is no.

Long answer is maybe partially. One could export rooms and characters and stuff easily enough but the scripting API and stuff will probably be fundamentally different and so conversion would be difficult.

Will Adore have the same way of scripting. Meaning the connection between the editor and scripting.

The editor and the scripts will be less connected than AGS because events and stuff dont need to be tied to hotspots, they are simply overridden from the base class.

LOVE has a built-in particle system: http://love2d.org/wiki/ParticleSystem

It's also rubbish. I would probably wrap it in something more complex.

Entrants should either be able to vote freely or be barred from voting entirely surely?

Anything else just skews the vote.

Oh  didn't know that wasn't made with AGS, I just played it. Very impressive game. Fullscreen just stretches it instead of actually changing the resolution of the game. I guess the only way around that is to sue polygons and texture filtering.

The current version of the engine resamples the game as the native screen resolution wherever possible and unless overrided by the user.

It froze the character after I looked at the yucca plant and I had to restart. Probably something with being at the edge of the walk path and turning to look at it.

This is a known bug and there's something wrong with the pathfinding algorithm but i can;t figure out what. I will get there eventually.

The only thing I didn't like was the taking away control while walking to an object, something like the GotThere module would make playing much less restrictive feeling.

That was an aesthetic choice in this case really. Adore does allow you to do this though:

Code: lua

--walk function is defined like this:
function character:walk(x,y,block,callback)

--this allows you to do something like this:

player:walk(200,400,false, function() 
    player:say("I arrived without being interrupted!")
end)

Basically whats happening here is that you are passing a function to the walk command which is run when the walk in completed if it's not interrupted.
Now, because Adore has a very flexible idea of what "blocking" means, this means that these actions can be independent of what the player is doing. Two characters can talk at the same time providing they're doing so in different coroutines. If the same character tries to talk in different coroutines then one will just block until the other has finished. Admittedly this could lead to some very odd behaviour if you didn't plan your game properly but there we are.

[/code]

I bet it's because no one appreciates him and because he hates CJ.

What's wrong with voting for one's own game? (I say this impartially as i have not entered)

Political candidates vote for themselves and if people are not allowed to vote for themselves then it potentially gives an unjust vote to someone else who they voted for because they could not vote for themselves.

Just food for thought.

I'd make it like SCUMM, an interpreter and you just make room scripts and the basic gameplay in separate files.

No, I think AGS has that side of things covered. I want to make something more flexible and modern.

Awesome that you're doing this though Calin. Will if be free for commercial use?

Thanks, yes.

Also if it has the locked mouse cursor and characters when scaling up with nearest neighbor like AGS does then I will certainly be the first to use it.

It will have both.

I'm a little concerned about the polygon paths for lower resolution games.

Modern, high res adventures are my aim. I think AGS has mostly got low res covered but I will consider bitmap masks if necessary.

Also changing the resolution and whether it's windowed in real time, enabling and disabling the nearest neighbor filter in real time as well would be cool.

Already done.

When I scaled up my Love2D game by x2 with nearest neighbor the objects floated between the pixels, probably to give a smoother movement but it really didn't look right at all.

Thats because you scaled up the coordinate system. You need to make a render target and scale that after drawing to it to keep the pixels native. Adore already does this.

But making the ending open and allowing the GUI and other things to be hard coded instead of sheets on top of an engine sounds awesome. Just using script files and not an editor would be my choice, but I'm sure if you want many people to use the engine then it should have an editor.

Due to the design of the engine you are perfectly able to write your entire game without ever opening the editor. All you need to do is code the characters and stuff manually.

Also cross platform. This will probably take a long time to make though I'm guessing?

Love is already cross platform and Adore is already cross platform by design.

Well, the MAGS game I released took two weeks, including building the skeleton engine that it runs on. The editor will take some time though.

Am I to take it that you know something about love? Tell me, what is love?

But yes, that is my initial plan.

Will there be some way to pack those folders into a resource file or something? While loading PNGs from folders is all well and good and easy, it does make a huge mess of the directory, looks horribly amateurish, and allows people to just pick up the resources and walk off with them, or easily edit them. And, well, I just don't like huge directories of resource files.

The data files will be attached to the EXE file much like AGS when you do a "release" compile but most of the time it'll just load the files from the directory tree. Of course the assets can still be extracted with relative ease. I'm not going to bother with encryption or anything.

Will there be support for actual vector graphics? I expect now that we're talking about high resolution graphics, they may as well be /resolution independent/.  I would love to see vector graphics being given the same ease of use as any raster format. And vectors are much easier to generate, nowadays!

There is support to draw arbitrary polygons and, with pixel shaders, you could implement some kind of vector rendering but i've no plans to implement vector graphics, no. The closest thing to vectors I plan to implement is tweened, bone based animation.

re: errors and exceptions

The unclear error messages is just a matter of proper error trapping which will come with time. Lua does have exception handling OOTB but there are ways we can augment it.

Code: lua

try(function()
    local x = nil
    x.pie = "yum" -- Oops! attempt to index nil!
end,
function (err) -- catch function
    adore.display(err)
end)

I'll probably override the error system in Lua because, usually, the errors passed are just strings which are awkward to interpret. So i'll pass objects instead with more info.

re: concurrency of commands.

This is something I've already considered a little. I think AGS runs certain things after the function has finished because there are certain game state changes (room changes especially) which would cause problems.
Adore will not have this problem because the game state is far more static. The only things that will get loaded and unloaded are assets like room backgrounds. So yea, Adore will allow things like room changes and dialogs to happen in the middle of a function. Indeed, Adore has a coroutine systems that allows you to run your own, non-blocking function and then return to it later where you left of.

I'm inclined to agree with dactylopus, in part.

If you ask for a sum of money and then are given ten times that sum and then say you need more because you've run out then something is very wrong somewhere.
While I'm sure that there was no ill-intent, it does strike me as incredibly naive for someone with as much experience in the industry.

Can you give us a hint about your way of organizing functions? Please.

All Adore's stuff would be under a single namespace (adore). So it would look like this:

Code: lua

adore.wait(1.5) -- wait for 1.5 seconds. (Adore will not be frame based but time based)

adore.currentRoom.hotspots[1]:interact() 
adore.rooms[1].hotspots[1]:interact() -- all hotspots and stuff will be global and all rooms will be editable at runtime.
adore.rooms[1].hotspots.hDoor -- hotspots can be accessed by name as well as index

--This seems longwinded but remember than in lua we can do this:

function myFunc()
    local hs = adore.rooms["myRoom"].hotspots.hDoor -- shorten the name for this function so its quicker to type and quicker to access.
    hs:interact()
    hs.name = "unlocked door"
end
    

My current plan is to make Adore something between a tool like AGS and a framework like love2d or xna or something.

The "tool", let's call it the Editor, would allow you to enter your data much like the AGS editor does. But when you "compile" your game, all it does it spit out Lua code which is then run by Love. This means no compiling necessary and it should be very fast. Adore will maintain no "sprite cache" like AGS does but just use pngs from a folder which can be updated at will and the changes will be reflected next time you run the game.

so for instance, you might use the Editor to create a character called Grundislav. The Editor would then spit out something like this:

Code: lua

local c = adore.character.new()
c.name = "Grundislav"
c.animations =
    {
        walking = 
            {
                left = adore.animation.new("gfx/grundislavLeft.png", 25,50) -- loads a sprite sheet where each sprite in the sheet is 25x50 pixels. Adore will do the rest. No views to worry about.
                right = adore.animation.new("gfx/grundislavRight.png", 25,50) 
            }
    }
c.walkingSpeed = 5
-- and so on
return c

Then the engine can just pick up this code and run with it. No compilation, no headaches.

It would be open sourced under the LGPL or something similar. A license that allows you to basically do what you like providing you give attribution where necessary and inform users of any changes. Having said that I would allow donations to be given and I think it would be fair to expect successful commercial projects to give me a kick back but no commercial license would exist.

In terms of cross platform support, it would be supported anywhere that Love2D and Lua are. Currently that is Windows, Linux, Mac and Android (preliminarily). There is also experimental HTML5 support for Love but I don't know how far along that is.

[Wait, it's coded in Lua? Won't that be really slow?]

Hello

As some of you may have seen, my last MAGS game was released using a different engine to AGS. I hope to continue its development further on and off over the next few months.

The engine aims to be a modern alternative to AGS which provides better support for high resolution games and which is hardware accelerated at all stages. The engine will use Lua scripting and use Love2D for its rendering and sound support. Because Adore will be coded in Lua at a very fundamental level all stages of the game will be overridable by the user either globally or for individual objects. Don't like the pathfinding? Feel free to write your own. Dislike the way Say commands are rendered? Just override it and the engine will continue as normal, calling Say commands just like the built in version.

Wait, it's coded in Lua? Won't that be really slow?

It's true that Lua is slower than raw c++ but AGS itself doesnt really do that much calculation under the hood. The most complex calculation is probably the pathfinder which usually has 2 or 3 nodes to consider and is over in a flash. The bottlenecks in AGS's speed are the CPU based rendering (dynamicsprites and so forth) which Adore does not have and it's unoptimized scripting language. My tests indicate that Lua is about an order of magnitude faster than AGS script in most cases. I've yet to find a situation in which AGS beats Lua for speed. (Cue monkey_05_06, stage left)

Why are you posting? Get on with it!

Adore will probably adhere to alot of AGS's conventions such as Characters, Rooms, Objects and so on but it does not have to. We have an opportunity here to reconsider the adventure game paradigm and create a tool that can facilitate that without being tied to an old code base. So I want to ask what *fundamental* things about AGS that you would change. How should objects and rooms work? How should the hierarchy be arranged? What annoys you about AGS? What things do you think AGS should be able to do that it does not?

Here are a few that I've already thought about and taken on board.

- The option for polygonal regions and walkable areas. High resolution games don't play well with bitmap masks and they are slower and use more memory.
- (optional) Sub pixel accuracy for all objects for smoother animations.
- A rethink of the "blocking" paradigm that AGS has. Multiple threads? Coroutines?
- Bone based animation built in.
- Pixel shaders.

Why are you posting on the AGS Forums about a competing engine? Are you mental?

I doubt Adore could replace AGS in a lot of ways. Firstly the barrier to entry is likely to be higher since AGS is very user friendly and Adore would be more modern and so require more programming expertise. Secondly I don't think Adore could cope with traditional, pixel art games as well as AGS can. AGS has that sierra/lucas arts feel down to a tee. With Adore I'm hoping to allow the creation of newer, more modern adventure games which is where AGS has traditionally struggled.

freesound.org is the best I think. The best I've found anyway.

I think there's a case to be made that The Longest Journey and Dreamfall approach the medium with the greatest maturity, especially in their portrayal of women. Both games contain female player characters who are strong without needing to appropriate masculine traits. These women are not sexualised either. Both games have the PC start in their pants but neither scene feels cheap, titillating or sexualised... they are just women in pants. (I would also argue that both scenes are noticeably symbolic and draw parallels between the two characters in their "waking up" stage).

I wouldn't go as far as to say they were the Citizen Kane of adventure games, since i don't believe such a thing yet exists, but they are certainly the most 'adult' games on offer.

Egyptians are a subset of everybody, so you said that Egyptians yearn for freedom, among many others.

Are you suggesting that RickJ is incorrect in suggesting that people yearn for freedom? If so then that is bizarre.

Spoiler

It was for her 20th birthday, I was mistaken.
The current year (according to the calendar) is 2009 so that makes her born in 1988.
The PC states he is two years older than her which means he was born in 1986
1988 + 1986 = 3974

[close]

Engine seems quite polished already, but I encountered a bug. When standing on the stairs and looking at the picture (that's hiding the safe), I got locked in position and couldn't move, so I had to restart.

The pathfinding is done using polygons in Adore instead of a pixel mask like AGS and the algorithm is still not perfect and occasionally the player can get caught in a corner.
Although I did think i'd fixed that... I will take another look.

Thanks for playing!

Unfortunately a lot of the basic designy stuff suffered due to the time constraints and having to build an engine.

Hopefully this month's MAGS will be more considered.

The pixel hunt is unfortunate and if I had time I would've changed that but that is how it goes I suppose. I'm glad you enjoyed it none the less.