[gamemode]The Ace

Intended for use on live public servers.
13 posts Page 1 of 1
Desert Storm
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 79
Joined: Wed Dec 18, 2013 3:45 pm


I am confident in my programming ability so this seems ready to posted however I could not test the features that require multiple players so if there is a problem post it here don't pm me. Anyways to use this just set the game mode to The Ace. The documentation is down below and in the script so even if you have been using a type-writer until a week ago you will know what to do.

Inspired by game mode in metroid prime hunters called Prime Hunter
Basically this is how the game mode works. This is a ffa style game mode and at the beginning of the match everyone is a standard player but, as soon as someone gets a kill they are labeled by the script as 'The Ace'. As the Ace you get damage boosts/resistances(configurable in the map.txt). However as time passes the Ace takes damage so the only way to stay alive is to kill more players which rewards the ace with more health. Also, You can't switch classes or teams as the Ace and you can not build or destroy blocks. When someone kills the Ace they inherit the status. If the Ace is not killed from a player then killing anybody will give the status again.

summary:
- ffa style(no team play)
- killing anyone gives you points
- get to max score to win
- the ace gets damage/defense boosts
- killing the ace passes on the title to the killer
- the ace can only get ammo from tents (no healing)
- the ace is unable to build/destroy blocks
- the ace loses health over time
- the ace is healed for every kill
Code: Select all
"""
The Ace
inspired by gamemode in Metroid Prime Hunters
by Desert Storm
"""

#You may modify this and post it elsewhere, however please leave the by Desert
#Storm part alone

#To get this working just set the game mode to "The Ace" don't include as
#a script
#I made this very dynamic so you can customize almost every attribute.
#Here is what you map.txt and/or config file can have included.
#Please note that anything that is in the map.txt file will override anything in the config file

#All options that are not map specific can be placed in your config file like so.
#"TheAce" : {
#   stuff goes in here
#}

#'ta':value not used(just use 0)
#if ALWS_ENBL is set to true BAM, The Ace is enabled. If it has this
#extension no matter what the value may be it is enabled

#'ta-heal':#>=0
#this is the amount of health that the ace gets when they kill someone.
#it can not be a negative value

#'ta-hit':#>=1
#this is the amount of damage that is dealt to The Ace when a clock interval is
#completed. The interval is explained below

#'ta-hit-interval':#>=1
#this is the amount of time in seconds that it takes for the ace to take passive damage

#'ta-damage-table':(#,#,#,#,#, #,#,#,#,#)>=1
#this is the damage table the values are Rifle, Smg, Shotgun, Grenade,
#and Spade in that order.
#the first five numbers are the multipliers applied to tha Aces' damage.
#the last five are the divisors for the damage that the ace takes.
#if a value is less than 1 it stays at the defualt

#'ta-score-table':(#,#,#,#)>=1
#this is the score table.the first number is a standard player on player kill.
#the second value when a player kills the Ace. thethird is when the ace kills
#a player. Finally the last value is the score that the ace gains after every
#hit interval

#'ta-max-score':#>=50
#this is the score that players must reach to win.

#'ta-build':True/False
#sets whether players are allowed to build/destroy blocks or not. Defaults to True

#'ta-spawns':[(x,y,z),(x1,y1,x2,y2),(x,y)]
#map specific
#If you want, you can define a set of spawn points which will be picked at random when a player spawns.
#There are three types of spawn points that you can define. Remember that y in AoS is not elevation.
#1. (x1, y1, x2, y2) - This will pick a random non-water location in the range of (x1,y1)-(x2,y2)
#2. (x, y, z) - This will just plop that player at the location
#3. (x, y) - If you just want the player to spawn at the highest point then use this. Also save space

#'ta-cp-spawns':[(x,y,z),(x,y,z)]
#map specific
#This is a list which must include two(2) pairs of xyz coordinates for the green and blue base respecively

#'ta-top-interval':#>=30 or #=0
#The time in seconds that players will be notified of the top scores.
#If zero(0) then the automated scoreboard message will be disabled

#'ta-top-num':#>0
#This is the number of players that are displayed by the automatic scoreboard or when a player calls 'ta-scores'

from operator import itemgetter
import random
from twisted.internet.task import LoopingCall
from pyspades.server import Flag, Base
from pyspades.constants import CTF_MODE, MELEE_KILL, GRENADE_KILL, SPADE_DESTROY, BLUE_BASE, GREEN_BASE
from pyspades.collision import vector_collision
from commands import get_player, alias, name, admin, add

HIDE_COORD = (0, 0, 0)
ALWS_ENBL = False
MSG_TA_ACE = 'the ace is {ta}'
MSG_TA_ACE_SELF = 'You have lost the ability to build or destroy blocks'
MSG_TA_NO_ACE = 'No one is the Ace'
MSG_TA_DEAD = 'The Ace is dead.'
MSG_TA_KILLED = '{player} is the new Ace.'
MSG_TA_TOP = '{rank}. {player} with a score of {score}'
MSG_TA_YOU = 'You have a score of {score} and are in position {rank}'
MSG_TA_SWITCH = 'You cant switch {switch} while you are the Ace'
MSG_TA_REFILL = 'You cant get health from base as the Ace. Kill someone to heal'
MSG_TA_WON = '{player} has won the Match'
MSG_TA_EXPLAIN = ['If there is no Ace kill someone to gain the status.',
                  'if there is an Ace kill them.',
                  'While you are the ace you take damage over time, but recieve a damage boost/resistance.',
                  'Reach {score} to win!']

@alias('tat')
@name('tatoggle')
@admin
def the_ace_toggle(connection):
    protocol = connection.protocol
    protocol.ta_enbl = not protocol.ta_enbl
    if protocol.ta_enbl:
        if protocol.ta_ace[0]:
            protocol.ta_hit_loop.start(protocol.ta_hit_interval, False)
        if protocol.ta_top_interval > 0:
            protocol.ta_top_loop.start(protocol.ta_top_interval, False)
        protocol.send_chat('The Ace match has been started')
    else:
        if protocol.ta_hit_loop.running:
            protocol.ta_hit_loop.stop()
        if protocol.ta_top_loop.running:
            protocol.ta_top_loop.stop();
        protocol.send_chat('The Ace match has been paused')
    connection.protocol.ta_reset_flags()
    return

@alias('tas')
@name('tascores')
def the_ace_scores(connection):
    protocol = connection.protocol
    scr = protocol.ta_scores[connection.name]
    scrs = protocol.ta_scores.items()
    scrs.sort(key=itemgetter(1), reverse=True)
    protocol.ta_top(connection)
    return MSG_TA_YOU.format(score = scr,
                             rank = scrs.index((connection.name,scr))+1)

@alias('tah')
@name('tahelp')
def the_ace_help(connection):
    msgs = []
    for i in MSG_TA_EXPLAIN:
        if i == MSG_TA_EXPLAIN[len(MSG_TA_EXPLAIN)-1]:
            msgs.append(i.format(score = connection.protocol.ta_score_max))
        else:
            msgs.append(i)
    connection.send_lines(msgs)
    return

@alias('ta')
@name('theace')
def the_ace(connection):
    protocol = connection.protocol
    msg = None
    if protocol.ta_ace[0]:
        msg = MSG_TA_ACE.format(ta = protocol.ta_ace[0])
    else:
        msg = MSG_TA_NO_ACE
    return msg

add(the_ace)
add(the_ace_help)
add(the_ace_scores)
add(the_ace_toggle)

def apply_script(protocol, connection, config):
    ta_config = config.get('TheAce', {})
    class tac(connection):

        def on_spawn_location(self, pos):
            protocol = self.protocol
            newPos = None
            if protocol.ta_spawns:
                spawn = random.choice(protocol.ta_spawns)
                if len(spawn) == 4:
                    newPos = protocol.get_random_location(True, spawn)
                elif len(spawn) == 2:
                    z = protocol.map.get_height(spawn[0], spawn[1])
                    newPos = (spawn[0], spawn[1], z);
                else:
                    newPos = spawn
            else:
                zne = None
                if protocol.ta_ace[0]:
                    player = get_player(protocol, '#' + str(protocol.ta_ace[1]), False)
                    loc = player.get_location()
                    zne = ((max(0, min(511,loc[0]-90))),
                           (max(0, min(511,loc[1]-90))),
                           (max(0, min(511,loc[0]+90))),
                           (max(0, min(511,loc[1]+90))))
                else:
                    zne = (0, 0, 511, 511)
                newPos = protocol.get_random_location(True, zne)
            return newPos

        def on_hit(self, damage, player, type, grenade):
            protocol = self.protocol
            if protocol.ta_enbl and player != self:
                weapon = self.weapon
                newDamage = damage
                if self.player_id == protocol.ta_ace[1]:
                    if type == GRENADE_KILL and grenade != None:
                        newDamage *= protocol.ta_damage_table[3]
                    elif type == MELEE_KILL:
                        newDamage *= protocol.ta_damage_table[4]
                    else:
                        newDamage *= protocol.ta_damage_table[weapon]
                elif player.player_id == protocol.ta_ace[1]:
                    if type == GRENADE_KILL and grenade != None:
                        newDamage /= protocol.ta_damage_table[8]
                    elif type == MELEE_KILL:
                        newDamage /= protocol.ta_damage_table[9]
                    else:
                        newDamage /= protocol.ta_damage_table[weapon+5]
                if connection.on_hit(self, newDamage, player, type, grenade) == False:
                    return False
                return newDamage
            return connection.on_hit(self, damage, player, type, grenade)

        def grenade_exploded(self, grenade):
            for player in self.team.get_players():
                if player == self:
                    continue

                damage = grenade.get_damage(player.world_object.position)
                if damage != 0:
                    returned = self.on_hit(damage, player, GRENADE_KILL, grenade)
                    if returned != False:
                        player.set_hp(player.hp - damage, self,
                            hit_indicator = grenade.position.get(), type = GRENADE_KILL,
                            grenade = grenade)
            return connection.grenade_exploded(self, grenade)

        def on_kill(self, killer, type, grenade):
            protocol = self.protocol
            if protocol.ta_enbl:
                if killer != self and killer != None:
                    if self.player_id == protocol.ta_ace[1]:
                        protocol.kill_ace(self, killer)
                        protocol.ta_scores[killer.name] += protocol.ta_score_table[1]
                    elif killer.player_id == protocol.ta_ace[1]:
                        protocol.ta_scores[killer.name] += protocol.ta_score_table[2]
                        hp = killer.hp + protocol.ta_heal
                        killer.set_hp(hp)
                    else:
                        if not protocol.ta_ace[0]:
                            protocol.kill_ace(self, killer)
                        protocol.ta_scores[killer.name] += protocol.ta_score_table[0]
                    killer.protocol.ta_check_score(killer)
                elif self.player_id == protocol.ta_ace[1]:
                    protocol.kill_ace(self)
            return connection.on_kill(self, killer, type, grenade)

        def on_login(self, name):
            self.protocol.ta_scores[name] = 0
            return connection.on_login(self, name)

        def on_weapon_set(self, value):
            if self.protocol.ta_enbl and self.player_id == self.protocol.ta_ace[1]:
                self.send_chat(MSG_TA_SWITCH.format(switch = 'weapons'))
                return False
            return connection.on_weapon_set(self, value)

        def on_team_join(self, team):
            if self.protocol.ta_enbl and self.player_id == self.protocol.ta_ace[1]:
                if team != self.team:
                    self.send_chat(MSG_TA_SWITCH.format(switch = 'teams'))
                    return False
            return connection.on_team_join(self, team)

        def on_block_build_attempt(self, x,y,z):
            if self.protocol.ta_enbl and (!self.protocol.ta_build or self.player_id == self.protocol.ta_ace[1]):
                if !self.protocol.ta_build:
                    self.send_chat('Building is disabled!')
                return False
            return connection.on_block_build_attempt(self, x,y,z)

        def on_block_destroy(self, x,y,z, mode):
            if self.protocol.ta_enbl and (!self.protocol.ta_build or self.player_id == self.protocol.ta_ace[1]):
                if !self.protocol.ta_build and mode == SPADE_DESTROY:
                    self.send_chat('Building is disabled!')
                return False
            return connection.on_block_destroy(self, x,y,z, mode)

        def on_refill(self):
            if self.protocol.ta_enbl and self.player_id == self.protocol.ta_ace[1]:
                self.send_chat(MSG_TA_REFILL)
                hp = self.hp
                self.refill()
                self.set_hp(hp)
                return False
            return connection.on_refill(self)

        def on_position_update(self):
            if vector_collision(self.world_object.position, self.team.other.base):
                self.check_refill()
            if self.protocol.ta_enbl:
                if self.player_id == self.protocol.ta_ace[1]:
                    team = self.team
                    loc = self.get_location()
                    loc = (loc[0], loc[1], 0)
                    team.flag.set(*loc)
                    team.flag.update()
            return connection.on_position_update(self)

        def on_flag_drop(self):
            self.protocol.ta_reset_flags()
            return connection.on_flag_drop(self)

        def on_flag_take(self):
            if self.protocol.ta_enbl and self.player_id != self.protocol.ta_ace[1]:
                return False
            return connection.on_flag_take(self)

        def on_flag_capture(self):
            if self.protocol.ta_enbl:
                if self.protocol.ta_scores[self.name] < self.protocol.ta_score_max:
                    return False
            return connection.on_flag_capture(self)

        def on_reset(self):
            if self.protocol.ta_enbl and self.player_id == self.protocol.ta_ace[1]:
                self.protocol.kill_ace(self)
            if self.name in self.protocol.ta_scores:
                del self.protocol.ta_scores[self.name]
            return connection.on_reset(self)

    class tap(protocol):
        game_mode = CTF_MODE
        ta_ace = [None, None]
        ta_enbl = False
        ta_hit = 5
        ta_hit_loop = None
        ta_hit_interval = 4
        ta_top_loop = None
        ta_top_interval = 90
        ta_top_num = 3
        ta_scores = {}
        ta_score_table = [1, 15, 5, 1]
        ta_damage_table = [1.4, 1, 1.3, 1.2, 2,  1.5, 1.5, 1.5, 2, 1.4]
        ta_score_max = 150
        ta_spawns = None
        ta_cp_spawns = None
        ta_build = True

        def ta_reset(self):
            for i in self.ta_scores:
                self.ta_scores[i] = 0
            if self.ta_hit_loop.running:
                self.ta_hit_loop.stop()
            self.ta_ace = [None, None]

        def ta_check_score(self, winner):
            if self.ta_scores[winner.name] >= self.ta_score_max:
                winner.team.score = self.max_score-1
                winner.team.other.flag.player = winner

                self.ta_ace = [winner.name, winner.player_id]
                winner.capture_flag()
                self.ta_reset()
                self.send_chat(MSG_TA_WON.format(player = winner.name))
            return

        def ta_reset_flags(self):
            if self.ta_enbl:
                flags = [self.green_team.flag, self.blue_team.flag]
                for i in flags:
                    i.set(*HIDE_COORD)
                    i.update()
            else:
                teams = [self.green_team, self.blue_team]
                for i in teams:
                    loc = i.get_random_location(True)
                    i.flag.set(*loc)
                    i.flag.update()
            return

        def ta_top(self, player = None):
            scores = self.ta_scores.items()
            scores.sort(key=itemgetter(1), reverse=True)
            for i in range(len(scores)):
                if i >= self.ta_top_num:
                    break
                if player:
                    player.send_chat(MSG_TA_TOP.format(player = scores[i][0],
                                                       rank = i+1, score = scores[i][1]))
                else:
                    self.send_chat(MSG_TA_TOP.format(player = scores[i][0],
                                                     rank = i+1, score = scores[i][1]))
            return

        def kill_ace(self, player, killer = None):
            if player.player_id == self.ta_ace[1]:
                player.drop_flag()
            if killer == None or killer == player:
                self.ta_ace = [None, None]
                self.send_chat(MSG_TA_DEAD)
                if self.ta_hit_loop.running:
                    self.ta_hit_loop.stop()
            else:
                self.ta_ace = [killer.name, killer.player_id]
                self.ta_scores[killer.name] += self.ta_score_table[1]
                self.send_chat(MSG_TA_KILLED.format(player = killer.name))
                killer.send_chat(MSG_TA_ACE_SELF)
                killer.take_flag()

                if self.ta_hit_loop.running:
                    self.ta_hit_loop.stop()
                self.ta_hit_loop.start(self.ta_hit_interval, False)

            return

        def hit_ace(self):
            if self.ta_ace[0]:
                player = get_player(self, "#" + str(self.ta_ace[1]), False)
                if player and player.name in self.ta_scores:
                    hp = player.hp
                    player.set_hp(hp - self.ta_hit, type = MELEE_KILL)
                    self.ta_scores[player.name] += self.ta_score_table[3]
            return

        def on_map_change(self, map):
            if not self.ta_hit_loop:
                self.ta_hit_loop = LoopingCall(self.hit_ace)
            if self.ta_hit_loop.running:
                self.ta_hit_loop.stop()

            if not self.ta_top_loop:
                self.ta_top_loop = LoopingCall(self.ta_top)
            if self.ta_top_loop.running:
                self.ta_top_loop.stop()

            ext = self.map_info.extensions
            self.ta_ace = [None, None]
            self.ta_scores.clear()
            self.ta_enbl = False
            self.ta_heal = 20
            self.ta_hit = 5
            self.ta_hit_interval = 4
            self.ta_top_interval = 90
            self.ta_top_num = 3
            self.ta_score_table = [1,15,5,1]
            self.ta_damage_table = [1.4,1,1.3,1.2,2, 1.5,1.5,1.5,2,1.4]
            self.ta_score_max = 150
            self.ta_spawns = None
            self.ta_cp_spawns = None
            self.ta_build = True

            if 'ta-hit' in ext:
                if ext['ta-hit'] >= 1:
                    self.ta_hit = ext['ta-hit']
            elif 'ta-hit' in ta_config:
                if ta_config['ta-hit'] >= 1:
                    self.ta_hit = ta_config['ta-hit']

            if 'ta-damage-table' in ext:
                for i in ext['ta-damage-table']:
                    if ext['ta-damage-table'][i] >= 1:
                        self.ta_damage_table[i] = ext['ta-damage-table'][i]
            elif 'ta-damage-table' in ta_config:
                for i in ta_config['ta-damage-table']:
                    if ta_config['ta-damage-table'][i] >= 1:
                        self.ta_damage_table[i] = ta_config['ta-damage-table'][i]

            if 'ta-heal' in ext:
                if ext['ta-heal'] >= 0:
                    self.ta_heal = ext['ta-heal']
            elif 'ta-heal' in ta_config:
                if ta_config['ta-heal'] >= 0:
                    self.ta_heal = ta_config['ta-heal']

            if 'ta-hit-interval' in ext:
                if ext['ta-hit-interval'] >= 1:
                    self.ta_hit_interval = ext['ta-hit-interval']
            elif 'ta-hit-interval' in ta_config:
                if ta_config['ta-hit-interval'] >= 1:
                    self.ta_hit_interval = ta_config['ta-hit-interval']

            if 'ta-score-table' in ext:
                for i in ext['ta-score-table']:
                    if ext['ta-score-table'][i] >= 1:
                        self.ta_score_table[i] = ext['ta-score-table'][i]
            elif 'ta-score-table' in ta_config:
                for i in ta_config['ta-score-table']:
                    if ta_config['ta-score-table'][i] >= 1:
                        self.ta_score_table[i] = ta_config['ta-score-table'][i]

            if 'ta-max-score' in ext:
                if ext['ta-max-score'] >= 50:
                    self.ta_score_max = ext['ta-max-score']
            elif 'ta-max-score' in ta_config:
                if ta_config['ta-max-score'] >= 50:
                    self.ta_score_max = ta_config['ta-max-score']

            if 'ta-build' in ext:
                self.ta_build = ext['ta-build']
            elif 'ta-build' in ta_config:
                self.ta_build = ta_config['ta-build']

            if 'ta-spawns' in ext:
                self.ta_spawns = ext['ta-spawns']

            if 'ta-cp-spawns' in ext:
                self.ta_cp_spawns = ext['ta-cp-spawns']

            if 'ta-top-interval' in ext:
                if ext['ta-top-interval'] >= 30 or ext['ta-top-interval'] == 0:
                    self.ta_top_interval = ext['ta-top-interval']
            elif 'ta-top-interval' in ta_config:
                if ta_config['ta-top-interval'] >= 30 or ta_config['ta-top-interval'] == 0:
                    self.ta_top_interval = ta_config['ta-top-interval']

            if 'ta-top-num' in ext:
                if ext['ta-top-num'] > 0:
                    self.ta_top_num = ext['ta-top-num'];
            elif 'ta-top-num' in ta_config:
                if ta_config['ta-top-num'] > 0:
                    self.ta_top_num = ta_config['ta-top-num'];

            if ALWS_ENBL or 'ta' in ext or 'ta' in ta_config:
                self.ta_enbl = True
                if self.ta_top_interval > 0:
                    self.ta_top_loop.start(self.ta_top_interval, False)
            self.friendly_fire = self.ta_enbl

            return protocol.on_map_change(self, map)

        def on_base_spawn(self, x, y, z, base, entity_id):
            if self.ta_enbl and self.ta_cp_spawns:
                if entity_id == GREEN_BASE:
                    return self.ta_cp_spawns[0]
                elif entity_id == BLUE_BASE:
                    return self.ta_cp_spawns[1]
            return protocol.on_base_spawn(self, x, y, z, base, entity_id)

        def on_flag_spawn(self, x, y, z, flag, entity_id):
            if self.ta_enbl:
                return HIDE_COORD
            return protocol.on_base_spawn(self, x, y, z, flag, entity_id)

    return tap, tac
Attachments
The Ace.py
The Ace game mode script.
(21.88 KiB) Downloaded 44 times
Last edited by Desert Storm on Fri Sep 23, 2016 10:38 pm, edited 9 times in total.
Desert Storm
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 79
Joined: Wed Dec 18, 2013 3:45 pm


Epic debugging skills have just been applied to this script Blue_Sunglasses1
Jdrew
Mapper
Mapper
Posts: 4808
Joined: Tue Oct 30, 2012 10:48 pm


could you provide a better description of what it does?
Dare
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 1187
Joined: Wed Sep 11, 2013 5:50 pm


Seems to me like pretty cool idea.
Are the Aces playing together in one team or can they fight each other?
How big advantages will be given if the Ace levels-up? Like how much power will give 1 level-up = ??? shoot power up, ??? health points up.
Jdrew wrote:
could you provide a better description of what it does?
Almost everything is explained in the OP. I think the description of what it does is almost complete, jdrew.
scrawl
Veterans
Veterans
Posts: 974
Joined: Mon Dec 16, 2013 12:09 pm


Seems like a cool gamemode.
Desert Storm
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 79
Joined: Wed Dec 18, 2013 3:45 pm


Dare[AoS] wrote:
Are the Aces playing together in one team or can they fight each other?
The way it works is kind of like if you played halo playing griffball with no teams. you pick up the ball everyone gets the message that you picked up the ball or in this case recieved the status and to make it easier to find the 'Ace' not only do they pickup the intel upon gaining the status, I added an on_position_update hook that sets the position of the other intel above the player.
Dare[AoS] wrote:
How big advantages will be given if the Ace levels-up? Like how much power will give 1 level-up = ??? shoot power up, ??? health points up.
There are not multiple levels of the 'Ace' status. It is either you are the ace or you are not the ace. As for the boosts if you had for this example a rifle and shot Blue_Pistol a normal player in the head it would do the normal amount of damage and they would die. I f you shot an ace they would not die right away due to this number in the damage table

```````````````Rifle damage resistance
````````````````````````/\
ta_dmg_table = (1.4,1,1.3, 1.5,1.5,1.5)

Now as you can see they just take half damage from everything(had to add resistances since you can't set health above 100) but,
if they just shot you in the body with a rifle you would leave with about 1 hp left. So as the ace you cant camp because everyone knows where you are and you can't run because the damage that you take will kill you overtime(look at ta_loop var in protocol) unless you kill someone to get more health. Oh and speaking of health the ace can not recover health from the cp they can only get more ammo.

And thanks to this explanation I realized there was a better way to only give the ace ammo when they go to a cp. will update shortly.
Dare
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 1187
Joined: Wed Sep 11, 2013 5:50 pm


Desert Storm wrote:
Dare[AoS] wrote:
How big advantages will be given if the Ace levels-up? Like how much power will give 1 level-up = ??? shoot power up, ??? health points up.
As for the boosts if you had for this example a rifle and shot Blue_Pistol a normal player in the head it would do the normal amount of damage and they would die. I f you shot an ace they would not die right away due to this number in the damage table

```````````````Rifle damage resistance
````````````````````````/\
ta_dmg_table = (1.4,1,1.3, 1.5,1.5,1.5)
This is the part I like most, surviving the headshot is kind of great feeling of safety when you're in game.
Desert Storm wrote:
Now as you can see they just take half damage from everything(had to add resistances since you can't set health above 100) but,
if they just shot you in the body with a rifle you would leave with about 1 hp left. So as the ace you cant camp because everyone knows where you are and you can't run because the damage that you take will kill you overtime(look at ta_loop var in protocol) unless you kill someone to get more health. Oh and speaking of health the ace can not recover health from the cp they can only get more ammo.
I think I get it, all of this can be still arranged if it won't seem balanced I guess, still i think you've made the whole script to be balanced for all players.
Desert Storm wrote:
There are not multiple levels of the 'Ace' status. It is either you are the ace or you are not the ace.
Oh sure, thanks for explaining this.

Seems cool, i'd say that it will require some testing, balancing the advantages of the Ace. So the eventually Ace won't be under/overpowered.
I really like the whole idea. :)
Desert Storm
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 79
Joined: Wed Dec 18, 2013 3:45 pm


Dare[AoS] wrote:
Seems cool, i'd say that it will require some testing, balancing the advantages of the Ace. So the eventually Ace won't be under/overpowered.
Thats the great thing about this script, I made it so almost every little variable is customizable from the map.txt(might change that to config not sure though) so tweaking the aces properties could be done to the users liking. Like if you wanted the ace to take less damage from the smg than the rifle you could do

*zeros left at default*
'ta-dmg':(0,0,0 1.5,2,0)

I know from my own experiences that people generally like non-mandatory customizations (under breath: darn you sims. I dont need no tutorial).
Ballistic
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 1207
Joined: Wed Dec 19, 2012 12:17 am


scrawl wrote:
Seems like a cool gamemode.
Bux Xray
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 218
Joined: Sat Aug 24, 2013 9:07 am


Ballistic wrote:
scrawl wrote:
Seems like a cool gamemode.
noobxd
Deuce
Posts: 1
Joined: Wed May 21, 2014 4:28 pm


Blue_BigSmile u.u
1Shot1Kill
Modder
Modder
Posts: 1708
Joined: Sun Mar 02, 2014 5:53 pm


noobxd wrote:
Blue_BigSmile u.u
What was the point of this post?
Desert Storm
3 Years of Ace of Spades
3 Years of Ace of Spades
Posts: 79
Joined: Wed Dec 18, 2013 3:45 pm


I finally found the time to fix this script... It's amazing how much I have improved in the time that I vanished from to now Blue_Tongue

All expected features have been fixed/implemented and I also added a few other extra customizations such as an optional spawn system, an automatic leaderboard (which can be disabled), and stuff like disabling building and stuff. Also, any settings that are not map specific can be placed in your servers config file.

See the instructions in the script for full details.

Also, if anyone happens to have a copy of my blood gulch map I made forevers ago, could you send it to me. I accidentally deleted my copy and the dropbox files.
13 posts Page 1 of 1
Return to “Completed Releases”

Who is online

Users browsing this forum: No registered users and 1 guest