Archive for the 'Progress' Category

The alpha is now online

Posted March 8, 2010 * Comments(0)

Now you can play the first alpha of the game, only a few people will be let in so hurry up and test it out!

To sign up go to http://alpha.bombwar.com and use the alphakey “wwbomb”

If you want to suport even more, join the facebook page and leave some feedback: http://www.facebook.com/bombwar

Cheers

Mikael

The first alpha is getting close

Posted December 13, 2009 * Comments(0)

Been working on the units and fighting system the last few days and now it is starting to look like something. Now it acually feels like its a game where you have some kind of goal :) Here is a video update that shows the new gui and unit system!

if the video looks blurry, go and check it out at screenr for some better quality, klick here.

Now its bed time, night!

Main theme soundloop

Posted December 3, 2009 * Comments(0)

Today I got the main sound loop for the game, I think it will fit perfectly, it has just the right feeling I was looking for. Click below to listen to it.

This movie requires Flash Player 10

Daniel Pharos made this great loop, if you ever need music made this is the guy to talk to. find him at Knights of Soundtrack or you could click here to go to his portfolio directly!

I will now add it to the game! yay!

And if you have not signed up for the beta testing go to www.bombwar.com and do so :)

Cheers

Beta countdown

Posted November 26, 2009 * Comments(2)

bw_landingscreen

Hello,

The beta countdown page is up, and the countdown will soon start. Be sure to go to www.bombwar.com and sign up for a beta key to be one of the first to play the game!

Cheers!

Todays game screenshot

Posted November 18, 2009 * Comments(0)

Here is just a screenshot from the game, the torrents is for defending the city against air units and airbombs. Every time you build a building the people need some place to live and each soldier needs a home, so you will need to have resident houses. Every building needs energy, so you have different energy supply buildings. In this screen you see the big energy supplyer, the nuklear reactor.

Night all!

bombwar_screenshot1119big

Click the image for full view.

First version to now

Posted November 16, 2009 * Comments(2)

Just looked at the early versions of the game, Ill post it here to show how much it changed :)

bombwar-graphics

At stage 1 and 2 I was not that happy with my pixeling, but the way it looks now works, I will probably change much of it later though (after the release that is) :)

A video update

Posted November 16, 2009 * Comments(0)

Here is a video update of the latest work. There are now 30 different buildings to build and upgrade. Each building require some resources and can also depend on other buildings (To see what I mean look at the mindmap in the last post).

I have moved the building and unit tools to the middle to make space for incoming / outgoing attacks. There will be some other stuff to the left aswell.

Now the explosions have a shake/light effect on the city when you get hit by bombs.

Laters!

Building mindmap

Posted November 1, 2009 * Comments(0)

Here is a mindmap that shows how the different buildings are connected in the game.

bombwar-mindmap

All the bug fixing

Posted October 5, 2009 * Comments(2)

No fun updates today, mostly different bug fixes for the map and building system. Now it seem to work fine, just need to add some security stuff for all the cheaters out there.

Bug fixing has to be the most boring thing in a project though, but it has to be done I guess :) Now I’m tired, time for some sleep time! nights

A PHP ByteArray class that works like the one in as3

Posted October 5, 2009 * Comments(0)

A lot of the data being sent from flash to php is just bytes to save bandwidth, so I wanted a php class that worked simular to the ByteArray class in actionscript 3. So I made this one.

Cheers

  1. <?php
  2. /**
  3.  * ByteArray class
  4.  *
  5.  * Should work close to the ActionScript 3 ByteArray class
  6.  *
  7.  * Copyright (c) 2009, Mikael Brandt.
  8.  * This code is free: you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation, either version 3 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this code.  If not, see <http://www.gnu.org/licenses/>.
  20.  *
  21.  * @author Mikael Brandt <mikaelbrandt@gmail.com> <www.mikaelbrandt.com>
  22.  * @version 1.0
  23.  *
  24.  * @copyright Copyright (c) 2009, Mikael Brandt.
  25.  * @license GNU General Public License
  26.  */
  27.  
  28. class ByteArray {
  29.  
  30.  /**
  31.   * The bytes.
  32.   *
  33.   * @var array
  34.   */
  35.  private $_bytes;
  36.  
  37.  /**
  38.   * Current byte stream position.
  39.   *
  40.   * @var int
  41.   */
  42.  public $position;
  43.  
  44.  /**
  45.   * Default constructor.
  46.   *
  47.   * @return void
  48.   * @param array[optional] $bytes
  49.   */
  50.  public function __construct($bytes = array())
  51.  {
  52.   $this->_bytes = $bytes;
  53.  
  54.   $this->position = 0;
  55.  }
  56.  
  57.  /**
  58.   * Get count of bytes in the byte stream.
  59.   *
  60.   * @return int
  61.   */
  62.  public function length()
  63.  {
  64.   return count($this->_bytes);
  65.  }
  66.  
  67.  /**
  68.   * Get the bytes left from the current position to the end of the byte array.
  69.   *
  70.   * @return int
  71.   */
  72.  public function bytesAvailable()
  73.  {
  74.   return count($this->_bytes) - $this->position;
  75.  }
  76.  
  77.  /**
  78.   * Replace the current position to a new value. If jump is true, then
  79.   * jump to the next position in the byte stream.
  80.   *
  81.   * @return void
  82.   * @param int[optional] $value
  83.   * @param boolean[optional] $jump
  84.   */
  85.  public function changeto($value = 0, $jump = false)
  86.  {
  87.   $this->_bytes[$this->position] = chr($value);
  88.  
  89.   if ($jump) $this->position++;
  90.  }
  91.  
  92.  /**
  93.   * Get the byte stream as a string.
  94.   *
  95.   * @return string
  96.   */
  97.  public function toString()
  98.  {
  99.   return implode($this->_bytes);
  100.  }
  101.  
  102.  /**
  103.   * Get the byte stream as base64.
  104.   *
  105.   * @return string
  106.   */
  107.  public function base64()
  108.  {
  109.   return base64_encode($this->toString());
  110.  }
  111.  
  112.  /**
  113.   * Reads a byte from the byte stream.
  114.   *
  115.   * @return int
  116.   */
  117.  public function readByte()
  118.  {
  119.   $returnByte = ord($this->_bytes[$this->position]);
  120.  
  121.   $this->position++;
  122.  
  123.   return $returnByte;
  124.  }
  125.  
  126.  /**
  127.   * Reads a 16-bit integer from the byte stream.
  128.   *
  129.   * @return int
  130.   */
  131.  public function readShort()
  132.  {
  133.   $returnShort = (ord($this->_bytes[$this->position])<<8) |
  134.       (ord($this->_bytes[$this->position+1]));
  135.  
  136.   $this->position +=2;
  137.  
  138.   return $returnShort;
  139.  }
  140.  
  141.  /**
  142.   * Reads a 32-bit integer from the byte stream.
  143.   *
  144.   * @return int
  145.   */
  146.  public function readInt()
  147.  {
  148.   $returnInt = (ord($this->_bytes[$this->position])<<24) |
  149.       (ord($this->_bytes[$this->position+1])<<16) |
  150.       (ord($this->_bytes[$this->position+2])<<8) |
  151.       (ord($this->_bytes[$this->position+3]));
  152.  
  153.   $this->position +=4;
  154.  
  155.   return $returnInt;
  156.  }
  157.  
  158.  /**
  159.   * Write a value to the byte stream at the current position.
  160.   *
  161.   * @return void
  162.   * @param int[optional] $value
  163.   */
  164.  public function writeByte($value = 0)
  165.  {
  166.   array_splice($this->_bytes, $this->position, 0, chr($value));
  167.  
  168.   $this->position++;
  169.  }
  170.  
  171.  /**
  172.   * Writes a 16-bit integer to the byte stream at the current position.
  173.   *
  174.   * @return void
  175.   * @param int[optional] $value
  176.   */
  177.  public function writeShort($value = 0)
  178.  {
  179.   array_splice(
  180.    $this->_bytes,
  181.    $this->position,
  182.    0,
  183.    array(
  184.     chr(($value >> 8) & 0xff),
  185.     chr($value & 0xff)
  186.    )
  187.   );
  188.  
  189.   $this->position += 2;
  190.  }
  191.  
  192.  /**
  193.   * Writes a 32-bit integer to the byte stream at the current position.
  194.   *
  195.   * @return void
  196.   * @param int[optional] $value
  197.   */
  198.  public function writeInt($value = 0)
  199.  {
  200.   array_splice(
  201.    $this->_bytes,
  202.    $this->position,
  203.    0,
  204.    array(
  205.     chr(($value >> 24) & 0xff),
  206.     chr(($value >> 16) & 0xff),
  207.     chr(($value >> 8) & 0xff),
  208.     chr($value & 0xff)
  209.    )
  210.   );
  211.  
  212.   $this->position += 4;
  213.  }
  214. }
  215. ?>

Next Page »