Jump to content
  • Advertisement

Search the Community

Showing results for tags 'HTML5'.

The search index is currently processing. Current results may not be complete.


More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Categories

  • Audio
    • Music and Sound FX
  • Business
    • Business and Law
    • Career Development
    • Production and Management
  • Game Design
    • Game Design and Theory
    • Writing for Games
    • UX for Games
  • Industry
    • Interviews
    • Event Coverage
  • Programming
    • Artificial Intelligence
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Engines and Middleware
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
  • Archive

Categories

  • Audio
  • Visual Arts
  • Programming
  • Writing

Categories

  • Game Developers Conference
    • GDC 2017
    • GDC 2018
  • Power-Up Digital Games Conference
    • PDGC I: Words of Wisdom
    • PDGC II: The Devs Strike Back
    • PDGC III: Syntax Error

Forums

  • Audio
    • Music and Sound FX
  • Business
    • Games Career Development
    • Production and Management
    • Games Business and Law
  • Game Design
    • Game Design and Theory
    • Writing for Games
  • Programming
    • Artificial Intelligence
    • Engines and Middleware
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
    • 2D and 3D Art
    • Critique and Feedback
  • Community
    • GameDev Challenges
    • GDNet+ Member Forum
    • GDNet Lounge
    • GDNet Comments, Suggestions, and Ideas
    • Coding Horrors
    • Your Announcements
    • Hobby Project Classifieds
    • Indie Showcase
    • Article Writing
  • Affiliates
    • NeHe Productions
    • AngelCode
  • Topical
    • Virtual and Augmented Reality
    • News
  • Workshops
    • C# Workshop
    • CPP Workshop
    • Freehand Drawing Workshop
    • Hands-On Interactive Game Development
    • SICP Workshop
    • XNA 4.0 Workshop
  • Archive
    • Topical
    • Affiliates
    • Contests
    • Technical
  • GameDev Challenges's Topics
  • For Beginners's Forum

Calendars

  • Community Calendar
  • Games Industry Events
  • Game Jams
  • GameDev Challenges's Schedule

Blogs

There are no results to display.

There are no results to display.

Product Groups

  • GDNet+
  • Advertisements
  • GameDev Gear

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


About Me


Website


Industry Role


Twitter


Github


Twitch


Steam

Found 19 results

  1. Hello! The game: https://www.combo-clicks.com/ DEV blog (so everyone can read the journey and some history): http://www.combo-clicks-dev.com/ TL;DR Feedback for Combo Clicks and also IDEAS for future games will be super appreciated (Hyper Casuals done in 3-4 weeks, each game with React Native). I will try to post on my blog atleast on weekly basis (both for gamers and developers) Thank you!
  2. Hello, this is beta v0.3.4 of our first game and we are looking for people who are goal oriented, hard working, communicates well and completes tasks in a timely manner. If this sounds like you, view our game, see if it interest you and send me a pm. https://gthedev.itch.io/world-ender-beta-v024We are looking to expand out team, to include another programmer and another artist. We have a lot of plans for the game and because of how large it is we need more help. This position is not paid, but will look good in a portfolio. The game currently has 5.5k views on itch where we test the game. Upon finished release we will be releasing it on Kongregate with the hopes to one day release it on steam. If the game makes money in the future, you will be paid a percentage of that earning based on how much you contributed. As of now, the game is free to play with no intention of in game purchases. Artist: Will be required to create pixel art which includes ships, weapons, planets, and unique bosses.Programmer: Will Assist me in adding events, streamlining content, voicing his/her opinion, creating snippets of code to implement, and debugging. The game currently has over 1000 events. With game completion at approximately 10%. We look forward to hearing back from you.
  3. Hey everybody, I'm currently working on a simple HTML5 game and my javascript collision detection function isn't working. The game features a little man that runs from side to side at the bottom of the screen, while a meteor falls from the sky. The function is supposed to detect a collision between meteor and man. In the routine, the top left corner of the man is at (player.x, player.y) and the top left corner of the meteor is at (meteor.x, meteor.y). The man is 25 pixels wide by 35 pixels tall. The meteor is 50 pixels wide by 50 pixels tall. Any idea where I've screwed in up this function? // ============================================================================= // Check for a collision between the 50 x 50 meteor and the 25 wide x 35 tall // main character // // Main character is drawn at 540 and is 35 tall, so the top of the character // is at y = 540 and the bottom is at y = 575. // // Function returns 1 if there has been a collision between the main // character and the meteor, otherwise it returns 0. // ============================================================================= function check_for_meteor_player_collision () { // edge positions for player and meteor var player_top = player.y; var player_bottom = player.y + 34; var player_left = player.x; var player_right = player.x + 24; var meteor_top = meteor.y; var meteor_bottom = meteor.y + 49; var meteor_left = meteor.x; var meteor_right = meteor.x + 49; var vertical_overlap = 0; var horizontal_overlap = 0; // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Check for vertical overlap // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Check if meteor bottom overlaps player if ((meteor_bottom >= player_top) && (meteor_bottom <= player_bottom)) { vertical_overlap = 1; } // Check if meteor top overlaps player if ((meteor_top >= player_top) && (meteor_top <= player_bottom)) { vertical_overlap = 1; } // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Check for horizontal overlap // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Check if meteor left side overlaps player if ((meteor_left >= player_left) && (meteor_left <= player_right)) { horizontal_overlap = 1; } // Check if meteor right side overlaps player if ((meteor_right >= player_left) && (meteor_right <= player_right)) { horizontal_overlap = 1; } // console.log("vertical_overlap = " + vertical_overlap); // console.log("horizontal_overlap = " + horizontal_overlap) // If we've got both a vertical overlap and a horizontal overlap, // we've got a collision if ((vertical_overlap == 1) && (horizontal_overlap == 1)) { return 1; } // if we've fallen through, we haven't detected a collision return 0; } // =============================================================================
  4. Just released another version of DRTS. You can play it at https://distilledgames.itch.io/distilled-rts Picking Maps I improved the UI to preview maps before starting to play with bots. Now it is easier to find a map you like and see what you are getting into before starting the game. Camera Controls In addition to earlier input methods, you now can control the camera also via keyboard: To pan, use arrow keys, for zoom plus and minus. To improve onboarding, I added buttons for controlling the camera. This visual addition to the UI should help new players notice that the field of view can be changed. Under The Hood To prepare for competitive games, the map generator was improved for exact symmetry of edges in generated maps. Pathfinding now yields optimal paths in more cases.
  5. The first implementation of DRTS came in form of a windows application. While the windows app did its job, I felt uncomfortable with the bottleneck resulting from depending on windows as a platform. To lower this barrier, I started developing a version to run in web-browsers. The web app has come a long way since then, offering an interactive tutorial and playing with bots. The update released today expands the web app by support for playing with other people online. To play the game, head over to play.drtsgame.com Starting today, the web app there also offers to join another player for a game. The video below demonstrates the new feature, using two different web-browsers: Under The Hood - Rendering Efficiency And Visibility Changes Also with this update, visibility of the game world is changed in several ways: The computation of visibility is reimplemented using a new algorithm to be more efficient in common scenarios. This change drastically improved frame rates in Firefox, Edge, and Chrome. Symmetry for view propagation along edges: With the new algorithm, visibility is changed for symmetry between pairs of nodes. This means that viewing along an edge always works in both directions, regardless of the travel direction of the edge. When the game is over, the complete game world is revealed to all players.
  6. Dead Chronicles

    Survival mode

    From the album: Dead Chronicles

    Demo version in HTML5
  7. jamespierce

    screenshot_2.png

    From the album: Pixel Memory

    Screenshot: Pixel Memory
  8. jamespierce

    screenshot_1.png

    From the album: Pixel Memory

    Screenshot: Pixel Memory
  9. This video shows part of the tutorial improved with DRTS release 2017-12-28. You can see the new slider control and additional visuals to guide the player. More on what has changed since the last release in the update at:
  10. Today I released a new version of DRTS. You can play it now at https://distilledgames.itch.io/distilled-rts The changes made since the last release are primarily about the tutorial and playing with bots. Tutorial Hugo Blanco recently helped me test the game. He patiently worked through the tutorial and so I learned about stumbling blocks in there. Based on these observations, I compiled a list of planned changes to improve the tutorial and UI Selecting The Split Ratio When testing the tutorial, we found a problem in the stage which instructs the player to split his unit. In the step to select the split ratio, there was insufficient guidance on how to proceed. I implemented several changes to improve this and also make the UI for this easier to use in general: In the tutorial step, visually point out a location the player can click on to complete the step. This is done by displaying an arrow pointing to the slider control. Make the slider control react to moving the mouse over it, to help understand that we can interact with this thing. Make the slider control work the same way with all mouse buttons. The video below shows how this part of the tutorial looks like now: Some other improvements made in the tutorial: Enable the player to complete the tutorial without relying on external instructions about camera controls: In the tutorial, the camera automatically follows the action to make sure the player can always see everything of interest. The visuals to draw attention to objects to interact with now also indicate if the player should use a specific mouse button. Playing with Bots There are now more maps to play on. You will find a new map each time you start a game. I expanded the map generation function to create symmetric maps. With this release, you will automatically get a symmetric map when starting a game. Since the last release, several bugs have been fixed: Fix a distracting visual glitch discovered by Hugo: Avoid splitting a unit when the resulting units are going to be merged in the next progress step anyway. Game World Movement: Opponents units block each others movement on opposite edges. Game World Movement: Opponents unit blocks movement from node to edge. Game World Combat: Make unit attack the unit blocking its movement with the highest priority.
  11. Viir

    2017-12-18.DRTS.play-with-bot.png

    This screenshot shows a game with the new bot and map. Screenshot from the DRTS Devlog at
  12. Following the plan from last week, I expanded the web port of the DRTS game. You can play this new version at https://distilledgames.itch.io/distilled-rts In the upper right corner of the screen, you will now find a button to access the main navigation, and from there, you can start new games. Besides the tutorial, you can also play on a larger map with a bot. To make this a bit more of a challenge, I spent a few hours on building a basic behavior for the bot. It will spread out, conquer more and more area on the map and eventually overrun you if you don’t act. I also started implementation of the map generator, which is used to generate random maps, and the new map you see is coming from this generator. A good part of the map generation functions are already implemented, but it needs some more work, most importantly to enable symmetrical maps. Symmetrical maps will come with a future release, as well as a user interface to customize the map generation process. The screenshot shows a game with the new bot and map.
  13. In part 1, I wrote about a difficulty endemic to just about any porting project, the importing and trans-coding of data to different formats. Here in part 2 I'll cover a few of the trickier engine architectural differences that exist between the original engine for Static:IT (Selenite) and the new engine that will support it (base-code from 96Mill and Revel Immortal) Different Origins Originally designed to support editor-only development of Adventure and RPG games, Selenite was a successor of the S3Engine (The Lost City of Malathedra); and shared many simularities with the primary exception being that S3 was designed such that scripts and associated resources were to be written in external tools, and the S3Engine was a pre-compiled exe run-time, that read and executed the scripts and resources. Selenite on the other hand, was an IDE, where game objects were added via a tree-view interface, along with resources; and the IDE was responsible for processing and packaging these resources for optimal end-use. The resulting resources were likewise run next to a pre-compiled SeleniteWin32.exe There is a relatively large expanse of time between the creation of Selenite in 2009, and the creation of Engine4 (or EngineIV ...it's not really important) in 2013; E4 represents several massive shifts in the way I build engines at least as of the time of this writing. It's in HTML5/JS, runs in the browser, and is 'wrapped' for platforms/services that only except exe, etc. It's heavily designed around The Trinity Pattern which is a design pattern I developed to aid in making a game expandable, without breaking save-games, or amassing technical-debt with each release. Dependency Injection and Law of Demeter are used heavily to reduce coupling It's a series of engines, where for each new game we clone the engine code of a game most like it; and features are selectively merged backwards if they're desired. Each game's run-time is optimized to that game, without regard for other games. This is to avoid having to square new features or feature modifications/removals against existing games. The Problems It became clear early in the port, that I was going to have an issue with the difference each engine handles a concept which I refer to as residency. In Selenite, there is the the Game class, which has a list of Room classes, and each of these rooms had a list of Actor classes; and when the game was loaded, that tree structure would be created and resident in memory; addressable at all times. ...not a terrible design, but one I had departed from a while ago; the primary issue is that Selenite mixes the issue of State and Runtime ...that is, objects are in charge of their runtime representation, mechanics and non-persistent state and they also hold their persistent (save game) state as well. In Engine4, the there is a separate class for a game object's persistent state, as well as its runtime. This allows an object's state to be retrieved, and passed into the construction of a newly minted runtime object. runtime objects can be created and destroyed at will, with its separate persistent state living on. This explicit separation of persistent state, as well as the tear-down and reconstruction of game objects is really helpful in allowing for game changes, additions/updates; without breaking previously saved game-state. ...however! That is really not important in the context of porting Static:IT So, the residency scheme in Engine4 (well new Static:IT's copy of it at least) needed to go, it simply wasn't worth trying to massage the wealth of code to deal with alternate mechanisms for modifying non-resident runtime state when I could bring the engine into alignment with the original needs. ...and thankfully, due to dependency injection and law of Demeter; the change was easy. Instead of creating and destroying each room, and its actors as the player traversed them, I was able to shift the code, changing mostly top-level factory functions, to create and maintain the total list of rooms and actors at start. ...in Part:3 I'll cover issues pertaining with porting the scripting from Lua to JS
  14. nbrosz

    Components and Messages in Unity

    Up to now, I have had a tendency toward monolithic classes when developing in Unity. My experience has always been with the typical object-oriented approach (with the exception of when I was developing using batari Basic), but I’ve been trying to train myself toward small, reusable components with focused purposes. I’ve had some good success lately, breaking larger scripts into smaller ones and using interfaces as a means of communicating between components where possible. public class ReportAttack : MonoBehaviour, IDamageable { public Team team; void Start () { team = GetComponent<Team>(); } void IDamageable.TakeDamage(MonoBehaviour from, DamageType type, float amount) { var attackerTeam = from.GetComponent<Team>(); if (team && attackerTeam && team.team != attackerTeam.team) Debug.Log(gameObject.name + " says: I've Been Attacked by " + from.gameObject + " on team " + (attackerTeam ? attackerTeam.team.ToString() : "no team") + " with " + System.Enum.GetName(typeof(DamageType), (DamageType)((int)type << 1)) + " (" + (int)type + ")"); } } While I’ve been fairly satisfied with the use of interfaces for calls to multiple or unknown components, I recall fondly the rapid development and flexible approach provided by utilizing messages in my 2017 Global Game Jam submission, Metalmancer. However, since Unity’s message passing uses reflection (or at least probably does, given that it takes the string name of the event to call), it does not perform particularly well. With that in mind, I hoped to make my own, alternative messaging system which is used much like the existing messaging system, but uses delegates and event handlers under the hood. This was the result. While I felt that I succeeded in my goal of providing a useful interface that hid the reflection-based old messaging system, I was crestfallen once I began running tests. On average, I see a performance increase of about 33% over Unity’s built in SendMessage, with the complication that all components using the new system must inherit from the new MessagingBehavior abstract class, rather than directly from MonoBehavior. Still, given that a direct call (as would be the case using an interface) is still about ten times faster, I wasn’t particularly encouraged by these results. On the other hand, as tomvds said in the Unity forums: Optimization is not about avoiding expensive code. It’s about avoiding expensive code where it matters. Still, stubborn as I am, it’ll be hard to convince myself to use even my own message passing architecture in lieu of more efficient interfaces. Or maybe I should just use an adaptation of wmiller’s Events system. Or I should just stop worrying about it. View the full article
  15. 'lo again all. I mentioned in my previous entry that I've been porting our 2009 release, Static: Investigator Training which is a C++/Direct3D/lua fmv horror adventure; to html5/js (canvas) using the base code from 96Mill and Revel Immortal as a starting point. The process has been going well, however there have been some sticky spots. extracting the original data from binary files atlasing approximately 300mb of png compressed graphics mimicking synchronous co-routine functions lua provided in JS differences between the original engine and the new engine re-re-remembering that everything takes way longer than you think it will I attacked what I thought would be the hardest problem first, which was extracting the original binary data. There were two forms of binary file classes.bin and game.bin; where classes.bin represented the data classes or 'templates' that described static, shared (by flyweight pattern) attributes for all three object types; game, rooms and actors. ...and where game.bin was in the exact form of a save-game, that represented a new-game initial state. That is representing the actual objects, their relationships (game has rooms, room has actors), starting attributes (position, animation, alpha, etc.) I used NodeJS to parse both of these files and export json equivalents of each file for easy access of data; I also took this opportunity to have computer assistance for renaming/transforming members to better match what the new engine would expect. Next I began to import the existing resources, which involved preparing them for a lot of atlasing Audio was simple, save for the shear amount of it; when starting a new HTML5 project; you always take size and amount of resources into consideration; it's like climbing Everest (not that I ever have) but everything you include needs to be downloaded by the user who is expecting a snappy game on their probably outdated tablet ...so you're careful. I didn't have any such luxury in the port, the final sound effect atlas came to 10 minutes; which should be fine. ...thankfully voice files are not atlased, as there is over 500 of them. In addition to atlasing, all of this data must be trans-coded as well, from source formats such as .wav, to deployment formats of .ogg and .mp3 ...why both? because depending on which device/browser/version you encounter some are only capable of running one or the other ...and some which are capable of playing both, are better at playing one than another ...and some devices outright lie. But this has gotten better over the years.
  16. francoisdiy

    Hacking Francois DIY

    From the album: Francois DIY 2017

    Francois DIY is written in 100% JavaScript and runs quite smoothly on the PC environment. Currently there are no plans to rewrite the code in other languages as there would be little improvement. It is open source and free to hack. I suggest using an editor with a code navigator or function lister for ease of access. There is also a built-in JavaScript debugger as well. Why JavaScript? The main purpose is to allow the app to demo on the browser as well as run on the PC. There are no plans to port to small devices. Possible future port with be on a tablet if they are powerful enough in the future. Not sure if recoding will be done in JavaScript.
  17. Palitri

    Html Space flyer

    A simple prototype for a 3d space/flight game done with Axis in 80 lines of code. Playable here http://palitri.com/axis/showcase/#Space
  18. Palitri

    Axis 3D for Web

    Axis is a free open source 3D engine for web pages and desktop applications. It's been a month since its official release with full source code, editor and all and there is more content available now like samples, info pages, API documentation and recently the team opened the discussion pages on the site where anyone can get help. From the team: Check out the latestaddition, a small 80-lines-of-code prototype of a space flyer game, playable on the web at http://palitri.com/axis/showcase/#Space You can learn more at http://palitri.com.
  19. khawk

    WebGL Insights Book Now Free

    The book WebGL Insights is now available for free as a PDF download. Published in 2015, CRC Press has made the book available for free, and it can be downloaded from the WebGL Insights Github page. Learn more from the book's website.
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

Participate in the game development conversation and more when you create an account on GameDev.net!

Sign me up!