AppGameKit Development Blog
THIS BLOG IS RETIRED NOW
FOR ALL THE LATEST NEWS JUST FOLLOW THE
APPGAMEKIT NEWS HERE
Hi, in the spirit of openness and transparency we're now publishing the progress of App Game Kit 2 Development.
AppGameKit V2017.09.04 RELEASED!
A couple of maintenance builds have been released during August & September. Read the news blog for more details.
AppGameKit V2017.7.19 RELEASED!
Phew, after a two month development phase we're proud to bring you a new version of AppGameKit with 3D Shadows, 3D Particles and many other fixes and improvements.
For the full details view the blog
announcement HERE.
AppGameKit Roadmap 2017
We’re well underway with our roadmap for AppGameKit in 2017 and have already seen the release of two new versions of AppGameKit and a new Sound Library DLC.
Following the community survey earlier this year we have now finalised our development goals and, in the coming months, the core engine of AppGameKit will receive these new features free to all existing users:
• Call DLL commands for Windows: Using these commands developers can call dynamic link libraries from their AppGameKit BASIC source code. Developers of DLL’s can also interrogate AppGameKit and call its commands.
• 3D Shadows: Automatic 3D shadow effects will be added to the 3D engine.
• 3D Particles: With this addition particles can be 3D in shape and move in three dimensions.
• Video Adverts: The Admob Video format will be supported within AppGameKit Tier1 BASIC.
• Box 2D enhancements: The full scope of Box 2D will be possible once these extra commands are released.
• Export to Windows, Mac & Linux from any platform: If you use AppGameKit’s IDE from Windows then you will be able to compile Mac and Linux executables from your chosen development OS. This also applies if you develop from Mac and Linux.
• Load & Save Arrays: Extra commands to quickly save out and load in array data.
These features will roll out in regular updates during the course of the year. Stability of the main AppGameKit product remains a high priority and we will continue to resolve any reported issues as we develop these new features.
We do have more features planned, and these will be made public once the above have been successfully released, but this includes:
AppGameKit VR (Q2 2017)
This new add-on DLC will provide a range of new commands that allow developers to code their own VR demos and games. Easy to use commands will turn on the Head Mounted Display of a VR headset. Touch and button commands report back what the user is doing with the connected touch devices. It will support both the Vive and Oculus devices.
AppGameKit Studio (Q3 2017)
The new AppGameKit Studio provides a Windows styled GUI where you can visually drag & drop, scale and move 2D media for your AppGameKit projects. With emulated display modes you’ll be able to quickly see how your app looks on different device resolutions. Studio will create 2D scenes and once finished they can be exported as BASIC or C++ source code to use in your projects.
Watch this space!
TheGameCreators
-----------------------------------------------------------
Development Update
30th January 2017
This month we've worked on some internal code changes within AppGameKit. We've seperated the OpenGL 3D calls so that they are all in their own source files. This does not affect the engine today but prepares the way for future development of the engine. We've also changed the build process to make it a faster process. Due to these changes our next version will be a BETA on Steam to check that it does not affect existing apps. We'll let you know when we're about to release it.
Fixes in the next version include;
* Fixed HTTPEncode entering an infinite loop
* Fixed Android export not working with Firebase if the Firebase config file contained details for more than one Android app
* Fixed PlayVideoToTexture on Windows not working with WMV videos
* Fixed exported APK crashing if it uses GameCenter commands but was exported without a Game Services ID
* Using InAppPurchaseSetup will no longer display a message box if it is called multiple times in the AppGameKit player, for example when broadcasting an app multiple times
* Updated Ouya export for the latest icon requirements
* Fixed SetObjectMeshFromMemblock sometimes corrupting the vertices of another object on non-Windows platforms
* Fixed 3D physics ragdoll commands reporting that a ragdoll does not exist when it does
* Fixed DrawSprite not using the scissor value set by SetSpriteScissor
* Fixed sprites with multiple images not using the scissor value set by SetSpriteScissor
* Fixed the skybox commands not working on some devices
* Added a new example project that experiments with Tone Mapping
* Removed hack on Android that was used to force the volume buttons to set the media volume rather than the notification volume, which may have been causing audio distortion
Help Guides are being written and released online. You can see the latest ones
HERE.
We're also creating
YouTube Tutorials.
Development Update
6th January 2017
Sorry for not updating this during 2016. I totally dropped the ball with this blog! As a company we still continued the development of AppGameKit, here are the 2016 hightlights;
Jan - iOS Player released
Feb - AppGameKit 2.0.17 - Terrain added
March - AppGameKit 2.0.18 - Maintenance build
April - Raspberry Pi free version
May - Tier 2 Starter Guide released
May - AppGameKit 2.0.19 - HTML5 support
May - Games Pack 1
June - AppGameKit 2.0.20 - Ogg Support, improved image loading speeds, lots of tweaks
July - New Asset Pack
Aug - Official Guides Updated
Sept - AppGameKit 2.0.21 - Video to texture, shared variables, camera commands + lots of tweaks
Dec - AppGameKit 2.0.22 - True Type Fonts & UTF8, lots of tweaks
TGC will be very focused on AppGameKit. We're starting off with a new maintenance build next week and we're also starting work on improving the documentation and examples.
Development Update
20th November 2015
The development focus for now is to keep fixing any issues found by the community to ensure V2.0.15 is a strong and stable build. We'll keep this focus up to the end of the year before making any new significant development plans for AppGameKit.
Development Update
23rd October 2015
We're currently preparing a full build of V2.0.15 for all platforms (iOS, Android, Mac, Blackberry and Linux)
All going well this will roll out as an Alpha build next week. We'll then see how users get on, fix any bugs and tweaks and after that make it a full official release.
Development Update
12th September 2015
We're working to bring you all a new build in the next 3-4 weeks time. There is some complex shader work that has to be created to make the new 3D commands easy to use and control.
In the meantime, here's the latest list of changes and also a list of new commands you can look forward to soon;
Features fixed and added to
* Added new string commands FindStringCount, FindString, FindStringReverse, CompareString, CompareStringIgnoreCase, ReplaceString, StripString, TrimString, TruncateString, CountStringTokens2, GetStringToken2
* Added SetTweenSpriteXByOffset and SetTweenSpriteYByOffset
* Added commands to create a custom tween with up to 4 float and 4 integer values, and read the values as it is running
* Added GetSpriteOffsetX and GetSpriteOffsetY to return the current offset point
* Fixed the tween commands not working properly when broadcasting multiple apps to a device
* Fixed DeleteAllSprites preventing text and edit boxes from drawing
* Fixed DeleteFile not refreshing the file list when using GetFirstFile
* Fixed OpenBrowser on Windows sometimes not detecting the correct default browser
* Added MinimizeApp command to minimize an app
* Fixed CreateMemblockFromImage not working on render images on Android
* Fixed render images becoming blank on Android when an app is sent to the background
* Added SetObjectZBias to prevent Z fighting
* Changed GetEditBoxChanged to no longer reset after being called, it will now return 1 until the next Sync or Swap call
* Fixed GetSoundsPlaying not recognising when a sound is stopped with StopSoundInstance
* Added a Log command that accepts a float to return the logarithm of a value
New commands coming soon!
This is a list from the new commands currently in their Tier2 state. They will soon be in Tier 1 BASIC too.
static void SetWindowAllowResize( int mode );
static void MinimizeApp();
static float Log( float a );
static float GetSpriteOffsetX ( UINT iSpriteIndex );
static float GetSpriteOffsetY ( UINT iSpriteIndex );
static int GetEditBoxCursorPosition( UINT index );
// Tweening
static void CreateTweenCustom( UINT tweenID, float duration );
static UINT CreateTweenCustom( float duration );
static int GetTweenCustomExists( UINT tweenID );
static void SetTweenCustomFloat1( UINT tweenID, float begin, float end, int interpolation );
static void SetTweenCustomFloat2( UINT tweenID, float begin, float end, int interpolation );
static void SetTweenCustomFloat3( UINT tweenID, float begin, float end, int interpolation );
static void SetTweenCustomFloat4( UINT tweenID, float begin, float end, int interpolation );
static void SetTweenCustomInteger1( UINT tweenID, int begin, int end, int interpolation );
static void SetTweenCustomInteger2( UINT tweenID, int begin, int end, int interpolation );
static void SetTweenCustomInteger3( UINT tweenID, int begin, int end, int interpolation );
static void SetTweenCustomInteger4( UINT tweenID, int begin, int end, int interpolation );
static float GetTweenCustomFloat1( UINT tweenID );
static float GetTweenCustomFloat2( UINT tweenID );
static float GetTweenCustomFloat3( UINT tweenID );
static float GetTweenCustomFloat4( UINT tweenID );
static int GetTweenCustomInteger1( UINT tweenID );
static int GetTweenCustomInteger2( UINT tweenID );
static int GetTweenCustomInteger3( UINT tweenID );
static int GetTweenCustomInteger4( UINT tweenID );
static void PlayTweenCustom( UINT tweenID, float delay );
static void UpdateTweenCustom( UINT tweenID, float time );
static void StopTweenCustom( UINT tweenID );
static int GetTweenCustomPlaying( UINT tweenID );
static void UpdateTweenSprite( UINT tweenID, UINT spriteID, float time );
static void UpdateTweenText( UINT tweenID, UINT textID, float time );
static void UpdateTweenChar( UINT tweenID, UINT textID, UINT charID, float time );
static void UpdateTweenObject( UINT tweenID, UINT objectID, float time );
static void UpdateTweenCamera( UINT tweenID, UINT cameraID, float time );
static void AddTweenChainCustom( UINT chainID, UINT tweenID, float delay );
static void SetTweenSpriteXByOffset( UINT tweenID, float beginX, float endX, int interpolation );
static void SetTweenSpriteYByOffset( UINT tweenID, float beginY, float endY, int interpolation );
// Strings
static int FindStringCount( const char* str, const char* findStr, int ignoreCase, int start );
static int FindString( const char* str, const char* findStr, int ignoreCase, int start );
static int FindStringReverse( const char* str, const char* findStr, int ignoreCase, int start );
static int CompareString( const char* str, const char* str2, int maxChars );
static int CompareStringIgnoreCase( const char* str, const char* str2, int maxChars );
static char* ReplaceString( const char* str, const char* find, const char* replace, int qty );
static char* StripString( const char* str, const char* chars );
static char* TrimString( const char* str, const char* chars );
static char* TruncateString( const char* str, const char* character );
static int CountStringTokens2( const char* str, const char* delimiter );
static char* GetStringToken2( const char* str, const char* delimiter, int token );
// 3D
static void LoadObjectWithChildren( UINT objID, const char *szFilename );
static UINT LoadObjectWithChildren( const char *szFilename );
static void DeleteObjectWithChildren( UINT objID );
static UINT GetObjectNumChildren( UINT objID );
static UINT GetObjectChildID( UINT objID, int childIndex );
static UINT GetObjectNumBones( UINT objID );
static UINT GetObjectBoneByName( UINT objID, const char *name );
static UINT GetObjectNumMeshes( UINT objID );
static char* GetObjectMeshName( UINT objID, UINT meshIndex );
static char* SetObjectMeshTexture( UINT objID, UINT meshIndex, UINT imageID, UINT textureStage );
static void FixObjectToObject( UINT objID, UINT toObjID );
static void FixObjectToBone( UINT objID, UINT toObjID, UINT toBoneIndex );
// Animation
static int GetObjectNumAnimations( UINT objID );
static char* GetObjectAnimationName( UINT objID, int index );
static void PlayObjectAnimation( UINT objID, const char *animName, float starttime, float endtime, int loop, float tweentime );
static void SetObjectAnimationFrame(UINT objID, const char *animName, float time, float tweentime );
static void StopObjectAnimation( UINT objID );
static void ResetObjectAnimation( UINT objID );
static void SetObjectAnimationSpeed( UINT objID, float speed );
static int GetObjectIsAnimating( UINT objID );
static int GetObjectIsTweening( UINT objID );
static float GetObjectAnimationTime( UINT objID );
static float GetObjectAnimationDuration( UINT objID, const char *animName );
// Bones
static void SetObjectBonePosition( UINT objID, UINT boneIndex, float x, float y, float z );
static void SetObjectBoneRotation( UINT objID, UINT boneIndex, float angx, float angy, float angz );
static void SetObjectBoneRotationQuat( UINT objID, UINT boneIndex, float w, float x, float y, float z );
static void SetObjectBoneLookAt( UINT objID, UINT boneIndex, float x, float y, float z, float roll );
static void SetObjectBoneCanAnimate( UINT objID, UINT boneIndex, int animate );
static void RotateObjectBoneLocalX( UINT objID, UINT boneIndex, float amount );
static void RotateObjectBoneLocalY( UINT objID, UINT boneIndex, float amount );
static void RotateObjectBoneLocalZ( UINT objID, UINT boneIndex, float amount );
static char* GetObjectBoneName( UINT objID, UINT boneIndex );
static float GetObjectBoneX( UINT objID, UINT boneIndex );
static float GetObjectBoneY( UINT objID, UINT boneIndex );
static float GetObjectBoneZ( UINT objID, UINT boneIndex );
static float GetObjectBoneAngleX( UINT objID, UINT boneIndex );
static float GetObjectBoneAngleY( UINT objID, UINT boneIndex );
static float GetObjectBoneAngleZ( UINT objID, UINT boneIndex );
static float GetObjectBoneQuatW( UINT objID, UINT boneIndex );
static float GetObjectBoneQuatX( UINT objID, UINT boneIndex );
static float GetObjectBoneQuatY( UINT objID, UINT boneIndex );
static float GetObjectBoneQuatZ( UINT objID, UINT boneIndex );
// Other
static void SetObjectScalePermanent( UINT objID, float x, float y, float z );
static float GetObjectWorldX( UINT objID );
static float GetObjectWorldY( UINT objID );
static float GetObjectWorldZ( UINT objID );
static float GetObjectWorldAngleX( UINT objID );
static float GetObjectWorldAngleY( UINT objID );
static float GetObjectWorldAngleZ( UINT objID );
static float GetObjectWorldQuatW( UINT objID );
static float GetObjectWorldQuatX( UINT objID );
static float GetObjectWorldQuatY( UINT objID );
static float GetObjectWorldQuatZ( UINT objID );
static void FixObjectPivot( UINT objID );
static void SetObjectDepthBias( UINT objID, float bias );
static float GetObjectDepthBias( UINT objID );
// Shaders
static void SetObjectShaderConstantByName( UINT objID, const char* szName, float value1, float value2, float value3, float value4 );
static void SetObjectShaderConstantArrayByName( UINT objID, const char* szName, UINT arrayIndex, float value1, float value2, float value3, float value4 );
static void SetObjectShaderConstantDefault( UINT objID, const char* szName );
static void SetShaderConstantArrayByName( UINT shaderID, const char* szName, UINT arrayIndex, float value1, float value2, float value3, float value4 );
// Physics
static void Create3DPhysicsWorld();
static void Create3DPhysicsWorld( float scaleFactor );
static void Set3DPhysicsGravity( float x, float y, float z );
static void Set3DPhysicsGravity( UINT vectorID );
static void Step3DPhsyicsWorld();
static void Reset3DPhysicsWorld();
static void Delete3DPhysicsWorld();
static void Debug3DPhysicsWorld();
static int Get3DPhysicsTotalObjects();
static int Get3DPhsyicsActiveObjects();
static int Get3DPhysicsTotalJoints();
//Shape Commands
static void SetObjectShapeBox( UINT objID );
static void SetObjectShapeBox( UINT objID, float sizeX, float sizeY, float sizeZ );
static void SetObjectShapeBox( UINT objID, UINT vectorID );
static void SetObjectShapeSphere( UINT objID );
static void SetObjectShapeSphere( UINT objID, float diameter );
static void SetObjectShapeCylinder( UINT objID, int axis );
static void SetObjectShapeCylinder( UINT objID, int axis, float height, float diameter );
static void SetObjectShapeCone( UINT objID, int axis );
static void SetObjectShapeCone( UINT objID, int axis, float height, float diameter );
static void SetObjectShapeCapsule( UINT objID, int axis );
static void SetObjectShapeCapsule( UINT objID, int axis, float sizeX, float sizeY, float sizeZ );
static void SetObjectShapeCapsule( UINT objID, int axis, UINT vectorID );
static void SetObjectShapeConvexHull( UINT objID );
static void SetObjectShapeStaticPolygon( UINT objID );
static void SetObjectShapeCompound( UINT objID );
//Rigid Body Commands
static void Create3DPhysicsDynamicBody( UINT objID );
static void Create3DPhysicStaticBody( UINT objID );
static void Create3DPhysicsKinematicBody( UINT objID );
static void Delete3DPhysicsBody( UINT objID );
static int Create3DPhysicsStaticPlane ( float normlX, float normalY, float normalZ, float offsetPosition );
static void Set3DPhysicsStaticPlanePosition( UINT planeID, float posX, float posY, float posZ );
static void Set3DPhysicsStaticPlaneRotation( UINT planeID, float angX, float angY, float angZ );
static void Delete3DPhysicsStaticPlane( UINT planeID );
static void SetObject3DPhysicsGroup( UINT objID, int group, int mask );
static int GetObject3DPhysicsGroup( UINT objID );
static int GetObject3DPhysicsMask( UINT objID );
static void SetObject3DPhysicsCanSleep( UINT objID, int canSleep );
static void SetObject3DPhysicsMass( UINT objID, float mass );
static float GetObject3DPhysicsMass( UINT objID );
static void SetObject3DPhysicsFriction( UINT objID, float friction );
static float GetObject3DPhysicsFriction( UINT objID );
static void SetObject3DPhysicsRollingFriction( UINT objID, float friction );
static float GetObject3DPhysicsRollingFriction( UINT objID );
static void SetObject3DPhysicsAnisotropicFriction( UINT objID, int type );
static void SetObject3DPhysicsMaxLinearVelocity( UINT objID, float maxLinearVelocity );
static float GetObject3DPhysicsMaxLinearVelocity( UINT objID );
static void SetObject3DPhysicsLinearVelocity( UINT objID, float dirX, float dirY, float dirZ, float initialSpeed );
static void SetObject3DPhysicsLinearVelocity( UINT objID, UINT vectorID, float initialSpeed );
static float GetObject3DPhysicsLinearVelocityX( UINT objID );
static float GetObject3DPhysicsLinearVelocityY( UINT objID );
static float GetObject3DPhysicsLinearVelocityZ( UINT objID );
//static void SetObject3DPhysicsMaxAngularVelocity(UINT objID, float maxLinearVelocity);
static void SetObject3DPhysicsAngularVelocity( UINT objID, float angX, float angY, float angZ, float initialSpeed );
static void SetObject3DPhysicsAngularVelocity( UINT objID, UINT vectorID, float initialSpeed );
static float GetObject3DPhysicsAngularVelocityX( UINT objID );
static float GetObject3DPhysicsAngularVelocityY( UINT objID );
static float GetObject3DPhysicsAngularVelocityZ( UINT objID );
static void SetObject3DPhysicsDamping( UINT objID, float linearDamp, float angularDamp );
static float GetObject3DPhysicsLinearDamp( UINT objID );
static float GetObject3DPhysicsAngularDamp( UINT objID );
static void SetObject3DPhysicsRestitution( UINT objID, float friction);
static float GetObject3DPhysicsRestitution( UINT objID );
//Contact Reports commands
static int GetObject3DPhysicsFirstContact( UINT objID );
static float GetObject3DPhysicsContactX();
static float GetObject3DPhysicsContactY();
static float GetObject3DPhysicsContactZ();
static int GetObject3DPhysicsContactVector( int outPosVec3 );
static int GetObject3DPhysicsContactObjectB();
static int GetObject3DPhysicsNextContact();
static int GetObjects3DPhysicsContactPositionVector( UINT objA, UINT objB, int outPosVec3 );
//Joint Commands
static int Create3DPhysicsPickJoint( UINT objID, int positionVec3 );
static void Update3DPhysicsPickJoint( UINT jointID, int positionVec3 );
static void Delete3DPhysicsPickJoint( UINT jointID );
static int Create3DPhysicsHingeJoint( UINT objA, UINT objB, int positionVec3, int rotationVec3, int disableCollisions );
static int Create3DPhysicsConeTwistJoint( UINT objA, UINT objB, int positionVec3, int rotationVec3, int disableCollisions );
static int Create3DPhysicsSliderJoint( UINT objA, UINT objB, int positionVec3, int rotationVec3 );
static int Create3DPhysicsFixedJoint( UINT objA, UINT objB, int positionVec3 );
static int Create3DPhysics6DOFJoint( UINT objA, UINT objB, int positionVec3, float rotationVec3 );
static void Set3DPhysicsJointSliderAngularLimits( UINT jointID, float lowerLimit, float upperLimit );
static void Set3DPhysicsJointSliderLinearLimits( UINT jointID, float lowerLimit, float upperLimit );
static void Set3DPhysicsJointConeTwistLimits( UINT jointID, float swingSpan1, float swingSpan2, float twistSpan );
static void Set3DPhysicsJointHingeLimits( UINT jointID, float minAng, float maxAng );
static void Set3DPhysicsJointBreakingThreshold( UINT jointID, float breakThreshold );
static void Set3DPhysicsJointEnabled( UINT jointID, int isEnabled );
static int Get3DPhysicsJointEnabled( UINT jointID );
static int Get3DPhysicsJointPositionVector( UINT jointID );
static int Get3DPhysicsJointRotationVector( UINT jointID );
static void Delete3DPhysicsJoint( UINT jointID );
//Compound Shape commands
static void AddObjectShapeBox( int objID, int positionVec3, int rotationVec3, int sizeVec3 );
static void AddObjectShapeSphere( int objID, int positionVec3, float diameter );
static void AddObjectShapeCapsule( int objID, int positionVec3, int rotationVec3, int sizeVec3, int axis );
static void AddObjectShapeCone( int objID, int positionVec3, int rotationVec3, int sizeVec3, int axis);
static void AddObjectShapeCylinder( int objID, int positionVec3, int rotationVec3, int sizeVec3, int axis);
//Exporting, Importing, and Deleting Collision Shapes
static int SaveObjectShape( UINT objID, LPSTR fileName );
static int LoadObjectShape( UINT objID, LPSTR fileName );
//Vector commands
static int CreateVector3();
static int CreateVector3( float x, float y, float z );
static void SetVector3( UINT vectorID, float x, float y, float z );
static void DeleteVector3( UINT vectorID );
static float GetVector3X( UINT vectorID );
static float GetVector3Y( UINT vectorID );
static float GetVector3Z( UINT vectorID );
static float GetVector3Distance( UINT vectorU, UINT vectorV );
static float GetVector3Length( UINT vectorID );
static float GetVector3Dot( UINT vectorU, UINT vectorV );
static void GetVector3Cross( UINT resultVec, UINT vectorU, UINT vectorV );
static void GetVector3Multiply( UINT resultVec, float multiplier );
static void GetVector3Add( UINT resultVec, UINT addVec );
Development Update
26th August 2015
Finally we have a real treat for you!
In this video we're showing the new bone based animation features that will be part of the next major update to AppGameKit. The demo is running at 400+ fps on a Windows PC and we also show it running very fast and smooth on an Android Nexus 7. The latter part of the demo shows the progress of the new physics engine which utilises Bullet Physics.
Development Update
13th August 2015
Eye candy is again in short supply but that doesn't mean we're not coding away on AppGameKit.
In our labs AppGameKit can now load a bone animated object and draw it with proper vertex weights, where one vertex can be influenced by up to 4 bones, with commands to move each bone around by name.
The system can also handle older DarkMatter 1 style models that used limb based animation instead of vertex weighted. Each limb is a separate object placed in a hierarchy and each can be colored, textured, etc, separately from the others, or even detached from the main object and made into a fully independent object, with its own child limbs going with it. The next step will be to use this system to show animated objects, hopefully this will be demonstrated next week.
The Physics work also continues with the next milestone focusing on;
* Compound Shapes
* Exporting, Importing, and Deleting Collision Shapes
* Contact Reports & Collision
* Joint Commands
Development Update
23rd July 2015
There's no special eye candy to show you at present but the team are working hard on the two largest new areas of development (3D & Physics). On the 3D side the meshes are now separated so objects only contain the position and state data whilst the vertices are in a mesh, similar to how DBPro does it. Where an object can contain many meshes, this also matches more closely with how the asset import library loads from the various files. We've also developed a scene graph and are making sure it's compatible with the physics engine. Physics can override the final world position of any object even if it is attached to some other object. The major next step is getting bones in and working, and making use of the new mesh structure to batch similar meshes even if they belong to different objects.
On the physics side the development is on schedule for the first milestone at the end of this month to have;
* Physics World commands
* Primitive creation commands
* Rigid body commands
* Non-object rigid bodies
Here's another demo of the rigid bodies in action;
In 2-3 weeks time we'll show you a demo of the animated 3D commands using bones!
Development Update
3rd July 2015
Work continues on the 3D Engine but sadly no eye candy just yet.
Getting Physical!
In the past week we've teamed up with Stab In The Dark Software who will be implementing the Bullet Physics commands for AppGameKit. Over the next three months they will create the commands that will power the 3D Physics for your AppGameKit games. As a quick test they were able to make this early demo to show 3D objects colliding and reacting.
So there's plenty happening behind the scenes, we've also manned up to split the work load (where it makes sense to do so) and we'll keep showing you demos as the 3D and physics progress!
Development Update
22nd June 2015
Today we're able to share a small video demo.
We've successfully loaded a .X file on both Windows and Android using the Open Asset Import Library.
Paul did some stress testing on Android using his Nexus 7 (2012 model). It is rendering 100 copies (not instances) of the 3D character (approx 8300 polygons), so it is pushing 830,000 polygons at 30 fps with 1 light. The Nexus 5 can do the same at 40-60 fps, which varies due to fill rate not polygon count.
We still need to work on animation and that might slow it down a bit, but we're not batching anything yet which might speed it up a bit. Windows in its current state can handle 1000 copies at 45fps which is limited by no batching, so we're happy with the test results so far!
Development Update
12th June 2015
We initially started looking at COLLADA 3D file format but have since decided to see if we can integrate the
Open Asset Import Library.
We have it built in to AppGameKit and so it'll be able to load any of the formats that Asset Import Library claims to support on its website, including .X. We have it compiling on Windows, and nearly compiling on Android, just a few errors with exceptions. We haven't yet hooked it up to the AppGameKit rendering pipeline but hopefully that won't be too much trouble. We're also researching bone animation and the latest standard Dual Quaternion skinning.
Development Update
3rd June 2015
Work has started on the 3D and physics systems for AppGameKit. Currently the work has been research based to establish how best to move forward. We're aiming to support the Collada 3D file format. AppGameKit now has an XML importer so we're able to read the Collada file structure. The next phase is loading in the geometry data into an AppGameKit object. We have exported an animated soldier from our Game Guru project and will use this as a test model for the first iteration. We've also been playing around with the Bullet Physics source code and have the examples compiling and running. There has been no integration yet with AppGameKit.
So all early days for this work but we would hope to be able to show you some visuals early July time.
V2.0.14 Released!
15th May 2015
Shaders
* Fixed LoadSpriteShader(filename) without specifying an ID not using the correct vertex shader
App Export
* Added a check for development profiles in the IPA export, use AdHoc or Store profiles instead
* Fixed error about missing file or directory when exporting Amazon or Ouya APK
* Fixed iOS export with the advert box unticked not removing the advertising identifier (IDFA) from the app
New Commands
* CreateMemblock command will now zero the memblock during creation
* Added GetSpriteScaleX() and GetSpriteScaleY()
* Added WriteString2 and ReadString2 that use a faster method of reading strings from a file
Sprites
* Added Spriter support with LoadSkeleton2DFromSpriterFile()
* Fixed SetScissor generating a warning in the debug log window
* Added ability to loop an animation a specified number of times with a loop count greater than 1
* Fixed a bug where drawing more than 12000 sprites that share the same image could end up drawing nothing
* Fixed crash if an item is deleted that is currently being tweened
* Fixed SetTextScissor not working properly when SetViewOffset or FixTextToScreen are used
iOS
* Fixed GetResumed not being called on iOS after the app goes to sleep for the first time
* Updated iOS AdMob SDK to 7.2.1 which fixes a black screen after showing a full screen ad
Android
* Updated Android Google Play Services (which includes the AdMob SDK) to 7.3
* Fixed Android not caching a full screen AdMob ad before the first call to CreateFullscreenAdvert
* Fixed switching edit boxes on Android sometimes hiding the keyboard for the new edit box
Debugger
* Enabled copying of debug variable values using Ctrl-C on a selected row in the Variables window
* Enabled copying of debug log text using Ctrl-C on a selected row in the Debug Log window
Misc
* Fixed ResetTimer not resetting to exactly 0 on some platforms
* Fixed DrawBox command sometimes producing boxes that aren't perfectly straight
Broadcasting
* Fixed not being able to stop broadcasting if the app generated a lot of warnings while running
V2.0.13 Released!
27th April 2015
We're currently adding in Spriter Pro support to AppGameKit!
The development team are meeting this week to discuss plans for the future 3D engine work for AppGameKit!
V2.0.12 Released!
18th April 2015
Thanks to the great feedback and support since the debugger released we're now able to bring you a new version of AppGameKit with these features and fixes;
* Updated help files to fix squashed logo in the top left
* Fixed Android apps sent to background returning as a blank screen
* Fixed broadcasting sometimes not being able to stop
* Typing a new variable expression in the debug tab whilst the app is paused now evaluates it immediately
* Fixed occasional crash on Android when ending a broadcasted app
* Fixed Facebook commands causing a crash on Android when used in an exported app
* Fixed fullscreen window on Windows sometimes shifting sprite positions downwards
* Fixed exporting of iOS apps from the IDE not passing validation
* Fixed declaring a local variable immediately after declaring a global variable in a function causing the local declaration to be skipped
* Fixed having a global variable declaration on the first line in main.agc causing a compiler crash
* Fixed resizing arrays with more than 2 dimensions using .length on the base array causing a crash
* Changed IDE project file to always save paths with forward slashes to make them portable across platforms
* Updated Chartboost SDK on Android to 5.2.0
* Added option to APK export to support expansion files, currently these can only contain video files and are loaded with LoadVideo("expansion:MyFile.mp4")
* Fixed SaveSound producing corrupt WAV files
* Fixed IPA export sometimes producing an error when nothing was wrong
* Added xxhdpi and xxxhdpi icons to the Android interpreter, when exporting use a 192x192 icon from now on
* Added new Android Tier 2 project interpreter_android_expansion that supports expansion files and builds with API 21
* Fixed tweens not changing a value if the start and end values are the same
* Added tween interpolation mode of -1 to turn off interpolation for a specified value
* Fixed tween chains containing delays jumping to the first frame of the next tween before the delay was finished
* Added SetTweenChainTime to jump to a specific time in the tween chain
* Added GetTweenChainEndTime to return the total length of the tween chain
* Fixed iOS exported apps being able to change orientation during startup before SetOrientationAllowed can take effect
* Fixed iOS exported apps always resuming in the initial interface orientation instead of the current interface orientation, if allowed
* Changed the Android text input method to use a hidden Android edit box to receive input, this should support third party input methods
* Fixed Android keyboard not being able to accept input on Android 5.0 when in landscape mode
V2.0.12 Released!
1st April 2015
No, not an April's fool, it's released with a full debugger!
Today we've rolled out the long awaited V2.0.12 of AppGameKit which now sports a new debugger in the IDE!
The debugger allows you to track changes to any type of variables, array and types. Simply add the variables you want to track in the Debug variables list and these will update as your step through your code. Break points can be placed anywhere in your code and you can step through it line by line when you want to hunt down an elusive logic error. The call stack will show you where code is being called from.
You can even Debug your code direct to your device. For example you can step through your code on your Windows PC and see the results on your Android phone running the AppGameKit Player app, all the values will be reported back to from the app and displayed in the IDE.
We hope you enjoy exploring this new feature of AppGameKit, it's very new so please report any issues back to us if you find any.
Misc fixes in this version
* Fixed an occasional crash caused by calling GetDeviceID()
* Fixed enlarging a multi-dimensional array using .length sometimes causing a crash
* Added a media refresh call after PrintImage() on Android to make the file appear to external apps
* Fixed repeated broadcasting apps leaking memory on the receiving device
* Fixed saving an image to the pictures folder with PrintImage on Android not refreshing the file system
* Fixed Android sensors all returning zero until the app is sent to the background and resumed
* Fixed a crash when passing a type returned from one function into multiple sub functions
* Fixed render images not being restored properly after resuming on Android
* Added SetEditBoxCursorPosition command to bring a certain portion of the text into view
* Fixed iOS exported apps not having the beta entitlement used for the new TestFlight implementation
* Fixed iOS exported apps missing the push notification entitlement
* Fixed network messages sent from one client to another not being received
* Added option to iOS export to add or remove the Advertising Identifier from the exported app
* AppGameKit apps run on Windows will remember their last window position when closed so they don't always start in the center of the screen
* Changed app closing on Android to use the finish activity method rather than force quitting the app, which looks like a crash to some devices
We hope you enjoy this new version. Have a Happy Easter next week, we'll be back to start on the new 3D commands very soon!
First sight of the Debugger!
20th March 2015
Here's a video of the new AppGameKit debugger in action;
First sight of the Debugger!
5th March 2015
Finally we can share some screenshots of the debugger progress! Not all of it is fully functional yet but it gives an idea of how it will work.
You can view the images of the Debugger here on
Facebook
The Debug Log at the bottom lists all the errors, warnings, or custom log messages that are output during the running of the program. The Debug window on the left will list a call stack showing what functions were entered to reach the current point, and a list of variables that a user can edit to watch specific values, which will activate when a breakpoint is reached (still to do).
The second screenshot shows the setting of breakpoints with red dots in the IDE (although these currently don't get passed on to the debugger so I can't show it stopping), and the stepping tools that will be available to move forward a line and over or out of functions, whilst watching the values on the left.
BASIC Debugger being Developed
20th February 2015
Debugging work continues. We have command stepping working, so you can now set a breakpoint in your code, wait for the program to hit it and pause, and then move forward a single line, jump into or over functions and jump out of functions. The next thing is to get some variable information back so when it is paused you can see what the value of specific variables are.
Visually there's nothing much to show and as soon as we have something visual to showcase we'll be posting it.
BASIC Debugger being Developed
15th February 2015
Just a quick update to let you know development of the debugger is well underway. We'll bring you some more detailed information about it when we have it up and running and presentable.
V 2.0.11 - released
3rd February 2015
For full details check the forum thread
here.
The changes so far for build 2.0.11 - coming soon...
22nd January 2015
* Fixed only being able to export the iOS player when no project is open
* Added Linux IDE, compiler, broadcaster, and player
* Fixed runtime errors in exported apps closing the app instead of displaying the error
* Made Android broadcast app paths case sensitive to match their exported versions
* Fixed a runtime error about no instructions found when assigning an array of strings some default values
* Fixed arrays of strings larger than their default values not initialising the rest to the empty string
* Changed export app name to accept a wider variety of characters
* Changed Random2(int,int) to accept and return values in the range -2,147,483,648 and 2,147,483,647
* Fixed iOS export sometimes not finding the Team ID in the provisioning profile
* Fixed videos not stopping on Android when the device is locked or goes to sleep
* Fixed landscape apps on Android sometimes continuing to run when the app is put to sleep
* Fixed .OBJ files taking a long time to load
* Fixed SeekMusic on Android always using absolute positioning even when mode is set to 1
* Allowed function parameters to have a new line after a comma
* Fixed GetVideoPlaying on Android still returning 1 when the video is paused
AGK V2.0.10 Released
4th December
AGK 2.0.10 Released to TGC buyers. Steam version update shortly.
Change log;
* Any AppGameKit players that have been compiled manually will need to be updated to work with this version, and AppGameKit players for this version will not work with old byte code
* Fixed a crash on Mac if loading an image greater than 2048x2048 that isn't divisible by an appropriate power of 2
* Fixed Blackberry lib missing SetSpriteAdditionalImage command
* Added support for Visual Studio 2013
* Updated the guides section of the help files
* Fixed push notifications not working on iOS 8 and sometimes freezing the app
* Fixed parsing of #insert causing an error
* Removing an item from an array with .remove() now initialises that array index back to zero if it is reused
* Fixed a compiler error when using a variable with inc or dec above the point where it is initialised
* Fixed DrawLine, DrawBox, and DrawEllipse sometimes having the wrong color value when rendering to an image
* Fixed For-Next loops defined in functions failing if the Step value is negative on one call and positive on another
* Set the default file encoding for new files to Windows-1252 to support extended ASCII
* Added Steam overlay to Windows interpreter when run from the IDE
* Fixed SetGlobal3DDepth not working and sprites always appearing in front of 3D
Please note that this version has updates to the AppGameKit player which mean it is not backwards compatible with old bytecode, and old players cannot run 2.0.10 bytecode, you will get a warning from the player if the bytecode is incompatible.
AGK2 Alpha 9 Released
* Fixed cut/copy/paste in Mac IDE dialog boxes not working properly
* Fixed cut/copy/paste in Mac and Windows IDE dialog boxes if the default key bindings are changed
* Fixed Mac menu bar not updating its shortcuts if the default key bindings are changed
* Fixed Android apps freezing when rotating the device after using SetScreenResolution
* Added build option to connect directly to a device IP for when broadcasting can't detect the device
* Fixed interpreter sometimes disconnecting from the IDE after broadcasting an app
* Fixed scissor commands not working when using SetRenderToImage
* Added SetSpriteAdditionalImage command to set multiple texture stages per sprite for use with shaders
10th November
All STEAM ahead!
The main focus for the past few weeks has been making AGK2 stable and ready for it's STEAM release. We wanted to keep Blackberry support so we have had to bring that code base up to date and it's taken a bit longer than expected. Some other tweaks and fixes have been made as users reported them in the TGC forums.
* Fixed DeleteTween crashing if the tween is currently in use
* Fixed arrays declared without a type but with a comment after them not appearing in the symbols list
* Fixed full screen adverts sometimes getting cropped
* Added support for Amazon Fire controller trigger buttons
* Changed Android fragment shaders to use highp precision if device claims support, since some devices incorrectly implement mediump as lowp. This may reduce performance so you are encouraged to override it with "precision mediump float;" if you want to force it back to mediump in all cases
* Fixed Mac LoadImage with the BlackToAlpha parameter set to 1 not working
* Fixed misspelling in the Android location permission causing it to fail
* Fixed GetSoundMaxRate on Android returning the minimum rate instead
* Fixed SetRawMousePosition not working properly on Mac
* Fixed #insert not being recognised by the compiler
* Fixed a bug causing IsSupportedDepthTexture to not be recognised as a valid command
* Fixed FacebookPostOnMyWall crashing if called when not logged in
* Added Blackberry support
We're aiming to release on Steam later this month and we'll be releasing with the competition demos. The author of the game Echoes+ has kindly allowed us to showcase his game as part of the STEAM release too.
24th October
Alpha 8 Released!
* Added Alt key code for Windows
* Added #option_explicit and #insert to the help files
* Added Spine commands to get animated bone positions in world coordinates
* Added Spine commands to get skeleton root position
* Added CreateFullscreenAdvert command to display AdMob interstitial ads
* Added SetChartboostDetails to allow the advert commands to display Chartboost ads (currently fullscreen only)
* Added support for using "#version <versionnum>" at the beginning of Windows shaders to allow higher versions
* Added GetRawGPSAltitude to all platforms
* Added XInput support for XBox 360 controllers on Windows
* Added GetRawJoystickConnected to detect if a joystick was removed or reconnected
* Added SetWindowSize to change window size and fullscreen modes instead
* Added install dialog to IDE Tools menu to allow manual installation of projects and tier 2 files
* Added SetCameraAspect to change the aspect ratio when rendering 3D
* Fixed a crash when deleting an image assigned to a cloned sprite
* Fixed local function variables not being assigned their default value
* Fixed float variables not accepting a default integer value
* Fixed broadcasting sometimes not sending updated files if the device time was ahead of the host time
* Fixed DeleteTween causing a crash on Android
* Fixed a crash when returning an array from a function that was declared inside that function
* Fixed global variables defined in functions with AS in a comma separated list creating both a global and local variable
* Fixed SetBorderColor not working properly on Mac
* Fixed using Exit, Continue, or ExitFunction inside a Case statement causing stack corruption
* Fixed Spine sprites sometimes disappearing when near the edge of the screen
* Allowed array default values to span muiltiple lines
* Changed SetScreenResolution to only accept width and height
* Changed default shader version on Windows to GLSL 110 to support OpenGL 2.0 cards such as old Intel integrated graphics
* Changed iOS magnet sensor commands to use the calibrated magnetic field
* Removed the ability to use Goto and labels inside select statements due to stack corruption
* Rearranged joystick button numbers on Mac so they match Windows and Android
* Opening configuration files no longer adds them to the current project
* Creating a new project with a path that doesn't end in a slash no longer causes an error when compiling
* IDE now remembers the order of tabs within a project
* When opening a project the IDE now opens files at last known cursor position
14th October
App Game Kit 2 is being prepared for a Steam release which should see it on the Steam store towards the end of November. Thanks to our existing relationship with Valve on FPS Creator Reloaded we were able to obtain a Steam product code without the need to run a Greenlight campaign.
We are still developing the features promised in the Kickstarter so you can expect to see the first implementation of the Tier 1 debugger when we release on Steam.
Here's a full list of changes since we released Alpha 7.1;
Opening configuration files no longer adds them to the current project
* Fixed a crash when deleting an image assigned to a cloned sprite
* Fixed local function variables not being assigned their default value
* Fixed float variables not accepting a default integer value
* Added Alt key code for Windows
* Allowed array default values to span muiltiple lines
* Fixed SetBorderColor not working properly on Mac
* Added #option_explicit and #insert to the help files
* Fixed using Exit, Continue, or ExitFunction inside a Case statement causing stack corruption
* Removed the ability to use Goto and labels inside select statements due to stack corruption
* Fixed a crash when returning an array from a function that was declared inside that function
26th September
Alpha 7.1 Released!
Hot on the heels on Alpha 7 comes Alpha 7.1!
* Fixed repeatedly pressing the back button crashing Android
* Fixed GetResumed() not working in tier 1
* Fixed "AGK Projects" folder getting installed in the "All Users" documents instead of the current user
* Added GetDocumentsPath() command to get the current user's documents folder
* Fixed iOS lib not working with iOS 8 SDK
* Upgraded iOS libs and projects to XCode 6 and iOS 8
* Updated AppGameKit icon
* Made APK export icon optional
* Made IPA export icon optional
* Fixed Close All Projects menu option not working
* Fixed Mac video position being incorrect if repositioned every frame
* Fixed a crash on Windows when switching music tracks
25th September
Alpha 7 Released!
* Removed dialog asking to create the new folder when creating a new project
* Updated the main.agc template to include window size commands
* Creating a new project no longer creates a setup.agc by default, it can still be used if desired
* Moved default installation path for "AGK Projects" folder to inside "My Documents" on Windows
* Moved AppGameKit write folder for apps from "My Documents/AGK" to "AppData/Local/AGKApps" on Windows
* Creating a new project will no longer overwrite main.agc if it already exists in the project folder
* Fixed compiler path being incorrect on Windows
* Fixed Mac IDE not liking spaces in its path
* Fixed a bug preventing arrays of types being passed into functions
* Attempted to target MacOS 10.7, unable to test (please let us know what you find)
* Added Arm 64 architecture to iOS lib
* Deactivated Twitter commands due to build problems with Arm64
* Fixed message window not remembering its height in some cases
* Changed Windows interpreter so it will attempt to load an "icon.ico" file before defaulting to the AppGameKit logo
* Fixed "open in new window" menu option not working
* Added IDE option to remember open projects when closing
* Fixed Mac compiler not replacing old .app file with the new version
* Added displaying of function parameters on typing a comma in addition to an open bracket
* Fixed broadcasted app not being able to play video if a previous app didn't delete its video
* Fixed Mac video position not matching the coordinates given
* Added SetSkeleton2DFlip to flip a skeleton in the horizontal or vertical axis
* Can now open a project or document's folder by right clicking on it in the side bar
17th September
Alpha 6 Released!
* Broadcasting now supported on Mac
* Export to Android APK on Windows and Mac
* Export to IPA on Mac
* New sensor commands on iOS and Android
* GPS support on all platforms (where available)
12th September
Lots achieved including Mac broadcasting and APK exporting!
Here's a run down of the updates coming your way next week in Alpha 6.
General Fixes
* Joysticks on Mac now work
* Fixed escaped strings (using single quotes) not correctly escaping new line characters
* Fixed FileEOF on Android APK apps not being consistent with other platforms (did not affect broadcasted apps)
* Fixed Facebook photo downloads going to different folders on iOS and Android, they will now both be placed in the current folder
* Fixed SetSpriteShapeCircle() with setPhysicsDebugOn() not showing the correct position of the shape
* Fixed HTTP file uploads on iOS when using HTTP authentication
* Fixed assigning a variable the lowest possible integer value -2147483648
* Fixed network bug where a disconnected socket would prevent the broadcaster reconnecting
IDE Updates
* Fixed adding new files to a project not updating the side bar properly
* Fixed syntax highlighting of hexidecimal numbers
* Fixed Dwmapi.dll sometimes causing a crash
* Added some themes for the main IDE look
* Added an IDE option to highlight other instances of the currently selected word (on by default)
* Fixed message window in Mac IDE getting progressively lower when auto hide is turned on
* Fixed paste not working in the Mac editor window
* Fixed Mac key bindings so they default to the Cmd key
* Added app broadcasting on the Mac
* Fixed Find In Files freezing the IDE on Mac
* Fixed Mac IDE sometimes saying compilation failed without showing the compiler errors
* Added export APK option to the IDE
Commands
* Added Gyro/Magnetic/Rotation/AmbientLight sensor commands for Android
* Added Gyro/Magnetic/Rotation sensor commands for iOS
* Added GPS commands to Windows, Mac, Android, and iOS
* Removed redundant ultrabook sensor commands like inclinometer, these can be calculated from the accelerometer
* Separated documentation for input commands into a raw section and a universal section
* Added GetFileCount and GetFolderCount commands
* Added GetDeviceID command
* Added CopyMemblock command
* Added runtime error for integer division by zero
* Updated help files for iOS and Android push notifications
* Added SetPushNotificaitonKeys so the AGKHelper.java file doesn't have to be edited
We're aiming to roll out Alpha 6 early next week and will be in touch with backers as soon as it's ready for download.
8th September
Last week has seen the completion of two new areas of development.
1. Mac app broadcasting is now working on the mac platform. This nicely rounds off the AppGameKit IDE solution for Mac.
2. We have also nearly completed an off-line APK builder. We decided to go about it slightly differently than the on-line method. Now individual permissions can be set by users, plus it makes it easier for us to keep it up to date.
We also have a couple of surprises for the next build!
Android now has a full set of sensor commands Gyroscope/Magnetic/Ambient Light/GPS (we know users have wanted these for a while). We just have to update iOS.
We may be able to export to XCode archive rather than IPA in the Mac IDE. An XCode archive would appear in the XCode organiser where it can be signed and converted to IPA or submitted to the App Store without having to use XCode to compile anything.
We'll aim to create a new build soon so you can get your hands on these nice new features.
29th August
Sorry for the lack of posts. I was away towards the end of July and part of August. Key developments since the last entry;
* IDE & Compiler now released for Mac!
* IDE fully implemented across Windows & Mac
*
AGK Player 2 released on Android
* Lots of bug fixes
* For full details check the
Kickstarter updates
18th July
The main work these past couple of weeks has been integrating project support into the new IDE system. It's proven to be a bigger task than expected but we are making good progress.
Learning the
Geany system and stripping out the current project system and then trying to replace it with a more suitable version for AGK2 projects. Once this hurdle is over we'll be back to making faster progress.
4th July
The new AppGameKit 2 IDE is now taking shape!
Currently the IDE can;
* Highlight your code syntax
* Fold code (functions, loops and comments)
* Symbol parsing - so you can easily see all the functions in your code and access them from a side panel
* As you type commands the IDE will present IntelliSense so you can quickly enter commands.
The IDE is a big step up from V1. It feels robust, feature rich and un-bloated
We're now working on connecting up the Compiler so code can be built. Then we'll be working on the debugger side of the IDE.
For images see the
Kickstarter Update HERE
27th June
The past week has seen us fix many compiler issues. The feedback from early testers has really helped us fine tune the new, faster Compiler.
Compiler Fixes
* Arrays in types not being able to accept values
* Passing arrays by value into functions causing a crash
* Negative values in constants causing errors
* Empty IF/ELSE statements not being accepted
* Using types of types in expressions
* Being able to declare functions without names
* Arrays can now be defined with no length parameter like "dim array[] as integer", the array will be empty until resized
* Array default values not accepting negative values
New Compiler features
* Array.sort() to sort array elements in ascending order
* array.insertsorted(expr) to insert an expression into a sorted array
* array.find(expr) to return the array index that equals the expr in a sorted array
* array.reverse() to reverse all the elements in an array
* Arrays of types can use the above sort/insertsorted/find functions, they will be compared based on the value of the first variable in the type
Some known issues that will be fixed in the next update
* DeleteAllSprites() prevents future sprites from being created
* All projects currently share the same interpreterV2 folder in the documents folder
IDE
For the IDE we are looking at
Geany which we have successfully compiled for Windows and Mac, and we are now modifying to work with AGK. It will of course be open sourced under GPL when we are done with it.
20th June
Today we have released the Compiler to all AGKV2 pledgers.
13th June
All existing language features have now been completed and testing with some existing projects shows very promising results. The compiler is about 40 times faster than before and the interpreter appears marginally faster although this hasn't been extensively tested yet. Byte code file sizes are now 7 times smaller when uncompressed, compressed size is about the same as before.
There are some additional languages features that the new interpreter supports but aren't yet exposed by the compiler, they are array inserting/removing/swapping elements, but first we want to make sure that existing projects are working exactly as with the old interpreter (or better).
11th June
The main Compiler work has been competed! Early tests are showing it's lightning fast compared to the older V1 Compiler. We'll bring more info to you on Friday!
6th June
The main development focus these past couple of months have been on the new Compiler and Interpreter. Here's a quick update on what's been achieved recently;
* User defined functions can now return types and arrays
* In general types and arrays can now be assigned to variables of matching types and passed to functions by value or reference.
* Parsing of IF statements is now completed
* Parsing of the 4 loop types DO, FOR, WHILE, and REPEAT is now completed
* All 4 loop types DO, FOR, WHILE, and REPEAT now have a new command CONTINUE which will skip the rest of the current iteration and move on to the next iteration.
* Parsing of SELECT statements is almost complete
After SELECT statements all the language parsing will be complete and testing on large real world projects can begin to check that there are no errors with existing tier 1 code, and give us an idea of compiling performance. Then the data (variables and instructions) will be packed into the byte code file format for the new interpreter and testing can begin to check it performs identically to the existing compiler and interpreter.
2nd June
Only a 3 day week last week due to the bank holiday and a day off on Friday so not a lot of progress, but I've nearly completed the function code for handling parameters and local variables. Functions now have the ability to return types and arrays and assign them to global variables or use them directly as parameters to other functions. This required a lot of care as temporary pointers created on the stack must be recognised when they are popped and properly freed so they don't leak memory, whilst types passed by reference must not be freed as it would destroy the original variable.
23rd May
This week Paul has finished the expression type casting work. So now it can also handle AppGameKit commands that have multiple compatible types. For example Str(int) and Str(float) would take Str(6) as an integer, where as Update(float) would take Update(6) as a float.
Paul has now moved on to function parsing which handles local variables and arrays. These are now placed on the stack instead of in global storage, and passing arrays and types by reference so that modifying their contents affects the original copy or passing by value so any changes remain inside the function” So basically variable handling is really working well.
We know the Compiler and Interpreter work has been going on for some time now but we're through the hardest part and should be looking to release a new Alpha in June for you all to start playing around with. Thanks for your patience!
19th May
Added code to validate function calls matching parameter count and types for AppGameKit commands and user functions. Added more expression rules for types and arrays so it can now parse expressions like;
"mytype.x = othertype.arrayoftypes[a].somevalue"
Arrays can be resized with "array.length = myType.num + 5".
At this point we started testing the bytecode output and realised it would also have to handle type casting so expressions like "a = 6.5" would function correctly if "a" is defined as an integer and promoting integers to floats in mixed expressions like "6.5 + 7" producing a float result. The changes to support this are nearly done. After which testing can resume to see if anything else comes up.
12th May
Implemented a new variable handler that should be able to deal with the various scopes (global, local, and function local). The parser can now recognise all the possible variable declarations, including old DIM style arrays and new array declarations of the form "myArray as integer[5]", type declarations, and default values for basic data types (integer, float, string + arrays). It can also now parse expressions like "a = 5+func()*b[5]" checking that every function, array, or variable is properly defined. Still to do is parsing conditionals and loops, and handling local variables inside functions.
6th May
We're still working on the parser to make sure it's backwards compatible with existing code, which has some interesting edge cases that need handling. For example when calling a gosub from within a function the gosub loses access to the function local variables and gains access to non-global variables outside the function. Hopefully we won't run into many more unusual cases this week and have something up and running soon. Cheers for being so patient while we work on this very deep part of AppGameKit V2!
28th April
The interpreter is now pretty much feature complete and multidimensional arrays are represented as arrays of arrays allowing each dimension to be resized individually. Work returns to the parser and making it output bytecode compatible with the new interpreter.
22nd April
Finalised the function call procedure that allows recursive functions with arrays, types, passing by reference or value, and added the ability to handle local arrays in functions. The next problem we're working on is how to handle multi-dimensional arrays, either flattening it into a single large array or having arrays of arrays which opens up interesting future uses. In particular what happens when either of these are dynamically resized, considering it has to be backwards compatible with existing functionality. Happy Easter BTW!
14th April
Started working in reverse and modified the interpreter to run a mocked up output of the parser as some difficult decisions had to be made about the best way to represent types and arrays in the final output. This will allow AGK2 to have arrays in types and in theory allow passing arrays and types through multiple levels of functions (still working that bit out). We can then make the two meet in the middle so the parser outputs what the interpre
