Hello.
I think that the best language for writing audio games is BGT.
Why? It generates very small executables, it contains all the functions
you'll need out-of-the-box and is simple to learn.
Python and PureBasic, on another hand, are general-purpose programming languages.
This means that you can create anything you want with them, but they contain only the basic tools to code the applications.
I think that you should try to code some offline games first.
Not will They give you more experience in writing code, with them you'll
learn the architecture of an audiogame and become proficient with the language you chose.
And most importantly, don't worry if you make misstakes. They are the
best ways to learn and improve.
Of course, that is only my oppinion.
While BGT is good for audiogame programming, Python and Purebasic can be
good to create very wide types of applications.
Hope this helps.

in which language is easier with the network?

The thing to keep in mind is that all programming languages share certain similarities, so learning one language can help you better understand and learn others. Whats important is to choose a language that you feel comfortable with. In time you will likely end up learning other languages and go from there.

As for networking, I not sure there's any particular language where networking would be considered "easy". In many cases networking could be considered a form of advanced programming as you should already have a grasp of the fundamentals before attempting it, the reason for this has more to do with the inherent problems with communicating securely and reliably between two computers more than it does with any particular language. Put simply, its much harder to suss out networking problems like Floating Point Determinism, Network Stability, and Communication Protocols when you don't even understand the language such problems are framed in. Focus on learning a language first, then start thinking about networking.

As i've suggested to others, I would recommend Python as its well documented, versatile, and easy to pick up. It does also have various network solutions and API's that you can look into as you become more familiar with it.

You can download Python here: Python 2.7.11

And check out the guide book Learn Python The Hard Way which can help you learn and familiarize you with the language by providing useful information, questions, and problems for you to solve.

Complexity is unfortunately an unavoidable occupational hazard of programmers, but if you already understand some amount of Python then I will skip ahead and suggest some API's you may find useful.

Pyglet has a number of built in audio functions and can handle wav files by default, you can also install AvBin to help load other audio formats like MP3's or OGG, but its been known to be quite tempermental. Pyglet also has bindings for OpenAL which can also handle 3D positional audio, I have some example scripts that demonstrate how to use them in my repository over here.

There's also PyAL, which is a more basic OpenAL API that doesn't handle graphics, keyboard, or mouse input the way Pyglet does. The examples in my respository are compatible with it however. Then there's Pyttsx which you can use for TTS speech. You could also look into PyGame, which has many of the capabilities of Pyglet.

For networking, you can use Twisted Matrix, it has a number of dependancies like Zope.Interface and PyWin32 you'll also need to install along side it however. It may be worth noting that much of my current networking experience is with Twisted Matrix integrated with Pyglet. You could also look into Pythons built in Sockets here and here. There are various tutorials and guides scattered about, and you could also try to find a copy of the book: Foundations of Python Network Programming, to help you along.

Here is a basic Pyglet script demonstrating keyboard input, creating a window, loading, and playing a sound:

import pyglet

#open a 640x480 window to display images and capture input.
window = pyglet.window.Window(640,480)

#load a sound
sound = pyglet.media.load('test.wav',streaming=False)

#capture key presses
@window.event
def on_key_press(symbol,modifiers):
    if symbol == pyglet.window.key.SPACE:
        print "Space Bar pressed"

#if press enter, play sound
    elif symbol == pyglet.window.key.ENTER:
        print "Playing sound"
        sound.play()

#capture key releases
@window.event
def on_key_release(symbol,modifiers):
    if symbol == pyglet.window.key.SPACE:
        print "Space Bar released"

#draw images to the window
@window.event
def on_draw():
    window.clear()

#start event loop
pyglet.app.run()

The OpenAL 3D audio examples in my repository are self contained and load wav files, to use them with pyglet or pyal, just comment and uncomment the required imports at the start of the script.

You can find a programing guide and Pyglet's documentation here in Pyglets repository. The [ a-t ] window.event is a pyglet function to check for a system event in the window, such as a key press or something being drawn to the screen, which then triggers the functions beneath the [ a-t ] window.event, such as on_key_press and on_key_release. Its not entirely necessary to use window.event, but that was just an example.

The [ a-t ] sign is part of how you set event handlers in Pyglet as discussed here in the documentation, though I rarely write code this way. For reference, here is another example not using such event handlers by sub-classing pyglets window class.

import pyglet

#sub class of window
class Example(pyglet.window.Window):
    def __init__(self):
    #have window sub-class call itself to set parameters
        super(Example, self).__init__(640, 480, resizable=False, fullscreen=False, caption="Test")

    #have pyglet repeatedly call our update function every 0.2 seconds
        pyglet.clock.schedule_interval(self.update, .02)

#main update loop
    def update(self,dt):
        self.draw()

#draw screen
    def draw(self):
        self.clear()

#capture key presses
    def on_key_press(self,symbol,modifiers):
        if symbol == pyglet.window.key.SPACE:
            print 'space pressed'

    #press escape to close program
        elif symbol == pyglet.window.key.ESCAPE:
            self.close()

#capture key releases
    def on_key_release(self,symbol,modifiers):
        if symbol == pyglet.window.key.SPACE:
            print 'space released'

#load custom window class
window = Example()

pyglet.app.run()

someone has examples sidescroller on PureBasic or python?

I'm currently writing side scroller in Python with Pyglet, accessible_output2 and sound_lib. I'll probably post tutorial once I complete enough basic stuff.

My email is [email protected]. My Skype is hrvojekatic. though you will need to introduce yourself in the introductory message since I don't accept people who I don't know.

Hi,
I'd recommend PureBASIC if you want a lot of functionality that's hard to find anywhere else (accept Python, which owns by comparison). I'd recommend Python if you want text processing services, binary data services, unusual data types, numeric and mathematical modules, functional programming modules, file and directory access, data persistence, data compression and archiving, file formats, cryptographic services, generic operating system services, concurrent execution, interprocess communication (IPC) and networking, internet data handling, structured markup processing, internet protocols and support, multimedia services, internationalization, program frameworks, graphical user interfaces (GUIs), development tools and libraries, debugging and profiling, software packaging and distribution, python runtime services, the ability to create your own custom python interpreters (within python itself), advanced module importers, python language services, miscellaneous services, Microsoft Windows specific services, Unix specific services, the ability to load antiquated and/or archaic modules, the ability to use undocumented modules, and the ability to embed and extend the interpreter, all built-in into the interpreter. PureBASIC has a lot of things that are unnecessary, but can be useful only at certain times.